Digital Design and Computer Architecture Portuguese Translation

Projeto Digital e
Arquitetura de Computadores
By David Money Harris & Sarah L. Harris
Esta traduo Portuguesa foi patrocinada

pela Imagination Technologies
Morgan Kaufman www.imgtec.com
English 2nd Edition 2013 community.imgtec.com/university
Esta edio do Digital Design and Computer Architecture de David Money Harris e Sarah L Harris publicada por acordo com a ELSEVIER INC.,
a Delaware Corporation com sede em 360 Park Avenue South, New York, NY 10010, USA
Publicada por Imagination Technologies
2nd Edio, Portugus, ISBN: 978-0-9954839-0-3
Elsevier, Inc. Todos os diretos reservados
2nd Edition, English, ISBN: 978-0-12-394424-5
Traduzido por Antnio Esprito-Santo e Renato de Macedo Giovanini
Antnio Esprito-Santo
Licenciado em Engenharia Eletrotcnica, ramo de Automao, Energia e Electrnica, pela Universidade de Coimbra e Mestre em Engenharia
Eletrotcnica, ramo de Sistemas e Automao, pela mesma Universidade. Obteve o Doutoramento em Engenharia Eletrotcnica pela
Universidade da Beira Interior onde atualmente Professor Auxiliar. Na Universidade da Beira Interior leciona unidades curriculares de Sistemas
Embutidos e de Instrumentao e Medida. Para alm disso coordena o Laboratrio de Investigao de Instrumentao e Sensores Biomdicos.
ainda investigador do Instituto de telecomunicaes.
Renato de Macedo Giovanini

Engenheiro Eletricista graduado pela Universidade Estadual Paulista - UNESP - Faculdade de Engenharia de Ilha Solteira, onde atualmente
desenvolve projeto de Pesquisa no LIEB - Laboratrio de Instrumentao e Engenharia Biomdica, na rea de Instrumentao Eletrnica aplicada
Engenharia de Reabilitao. J atuou como professor ou instrutor em diversas reas, de msica a cursos pr-vestibulares.
Se tiver sugestes e/ou correes por favor envie para Antnio Esprito-Santo.
ii
Material Ensino: MIPSfpga
Introduo
O MIPSfpga disponibiliza o cdigo-fonte RTL do ncleo MIPS microAptiv para implementao numa FPGA, juntamente com materiais de
ensino. O ncleo MIPS microAptiv UP um membro da mesma famlia de microcontroladores encontrados em muitos dispositivos embarcados,
incluindo o popular microcontrolador PIC32MZ da Microchip e o novo Artik1 da Samsung.
Os materiais de ensino iro mostrar-lhe como usar este ncleo como parte de um curso de Arquitectura de Computadores, abrindo o caminho
para que os seus alunos possam explorar o modo como o ncleo de um processador comercial com pipeline trabalha internamente e possam
usar este ncleo em seus projetos, criando os seus prprios projetos SoC.
Com a sua longa herana e excelente documentao, a MIPS a escolha preferida de arquitetura RISC para muitos professores em todo o
mundo. Mas, no passado, para demonstrar conceitos-chave, os professores tiveram de se contentar com a criao de ncleos parciais "MIPS-like
'ou usar cpias no oficiais de herana dbia. Agora no! o MIPSfpga o verdadeiro RTL 'industrial', no ofuscado, e est disponvel livremente
para uso acadmico.
Estrutura
Os materiais pedaggicos MIPSfpga so compostos de trs partes:
O Getting Started Package contm um guia detalhado que comea com uma breve introduo ao ncleo MIPSfpga includo no pacote.
Ele d uma viso geral de como configurar o ncleo para a simulao ou coloc-lo numa FPGA, assim como a programao do processador.
Orientaes sobre a instalao do software tambm so dadas, juntamente com detalhadas e instrues de referncia sobre o ncleo e
iii
a sua ISA - Instruction Set Architecture, o Guia do System Integrator e como usar as UDI - User Defined Instructions. Todos os usurios
precisam deste pacote, em primeiro lugar porque ele contm a RTL, os guias de referncia, um instalador OpenOCD + Codescape
Essentials e outros componentes. O Getting Started Guides em outros idiomas so apenas tradues do guia.
MIPSfpga Fundamentals. Aqui o leitor vai encontrar slides acompanhado de roteiros de laboratrio, ilustrando o uso da Digilent Nexys 4
DDR ou outras plataformas. Com isso, ser levado desde construir o ncleo at programao em C e assembly, com 9 exerccios para
completar ao longo do caminho. O leitor, ento, pode avanar e adicionar uma variedade de perifricos ao ncleo de modo a permitir
um maior nvel de interao. O ltimo exemplo ilustra como portar o MIPSfpga para outras placas FPGA, tais como, a Basys 3.
MIPSfpga SOC. Este pacote avanado permite que execute o Buildroot Linux no MIPSfpga especificamente utilizando a plataforma Digilent
Nexys4 DDR. O ncleo microAptiv empacotado como um bloco IP utilizvel por Xilinx Vivado IP Integrator. Como resultado, o AXI
baseado nos blocos de IP da Xilinx pode facilmente ser conectado com o ncleo MIPS. Estes so usados para criar um exemplo SoC, como
um projeto com uma UART e Ethernet, rodando sob Linux, em MIPSfpga. Um bloco GPIO AXI personalizado juntamente com um exemplo
de driver em Linux tambm fornecido. H extensa documentao includa. Coletivamente estes constituem uma excelente base para
um curso SoC sendo altamente relevante para as necessidades da indstria de projeto de chips, embora o nvel de complexidade a destine
a uma ps-graduao. Os estudantes de doutoramento e ps-doc vo tambm reconhecer que este material ser muito til para os seus
projetos de pesquisa.
Cursos Alvo e Projetos (Nvel de Escolaridade)

Projecto Digital & microarquiteturas (BSC)
Organizao de Computares & Arquiteturas, Arquiteturas Avanadas de Computadores (Licenciatura, Mestrado)
Projeto SoC (MSc)
Verificao de Projeto (MSc)
Projeto de Sistemas Embarcados (Licenciatura, Mestrado)
iv
Arquitetura de Processadores: modificaes, melhorias, otimizao ... (MSc, PhD)
Os Autores
Os materiais do curso foram desenvolvidos por David Harris e Sarah Harris, co-autores do popular
livro Digital Design and Computer Architecture, e fornece um acompanhamento exclusivamente
relevante da MIPSfpga).
Materiais Complementares
Livro de texto Computer Organisation and Design de David Patterson e John L. Hennessy
continua a ser a "bblia" para essas atividades, e fornece mais profundidade ao Harris & Harris num
curso baseado em MIPSfpga.
Outros livros relevantes so referenciados aqui

http://community.imgtec.com/university/resources/books/?subject=mips-architecture
Aceda ao ncleo microAptiv em silcio atravs de placas, como Digilent 'WiFire' incorporao da
Microchip PIC32MZ MCU
Vdeos do workshop dadas por Sarah Harris e Parimal Patel da Xilinx on-line Aqui:
http://community.imgtec.com/university/video-gallery/
Programa global de Workshops: a ser anunciado na pgina Eventos Universitrios.
v
Ferramentas requeridas
Hardware
Host PC: Windows 64 bits
Digilent Basys 3 ou Nexys 4 DDR, com Xilinx Artix 7 FPGA
Adaptao a outras placas foi demonstrada: Zed board, Nexys 3, Nexys 4 (not DDR) etc.
programador JTAG: SEEED Studio MIPS Bus Blaster incluindo o adaptador de 14 para 12 pinos para a placa Nexys4 DDR
Software
Codescape MIPS SDK Essentials (instalador includo com o Getting Started Package)
OpenOCD (Instalador includo com o Getting Started Package, ou verso offline disponvel para download do site do IUP)
Vivado (Xilinx) Web Pack Edition
Mentor Graphics ModelSim (Student ou Full editions) ou Xilinx Xsim
Disponibilidade
Imediata: MIPSfpga Getting Started ver. 1.3, MIPSfpga Fundamentals 1.3, MIPSfpga SOC ver. 1.0
vi
Lnguas em que o Getting Started & Fundamentals est atualmente disponvel
Ingls
Chins simplificado
Japons
Russo
Espanhol
Suporte
O frum Insider MIPS aqui tem uma linha especificamente para questes tcnicas sobre o MIPSfpga.
O frum do IUP (Imagination University Programme) aqui para discusso de currculos e outros assuntos.
Parceiros
Temos trabalhado em estreita colaborao com a Xilinx e a Digilent que deram um apoio maravilhoso a este projeto grande e complexo. Os
detalhes sobre seus programas universitrios est aqui:
vii
Como se juntar ao IUP e aceder a estes materiais
1. Clique em "Register" ou "Join IUP na pgina de principal: www.imgtec.com/university
2. Complete a primeira seo: the Community Registration
3. Marque a caixa selecionada Join Imagination University Programme e complete a informao adicional
4. Um e-mail de verificao ser enviado para si para ativao. (Por favor verifique, tambm, a caixa de correio de spam, porque de vez em
quando o correio filtrado)
5. Para fazer download dos materiais de ensino, visite a pgina IUP - Teaching Resources http://community.imgtec.com/university/resources/
6. Solicitar o pacote (s) que deseja, aceite o contrato de licena, e fornea alguns detalhes sobre como pretende usar os materiais.
7. Em seguida, iremos receber um pedido para aprovar a sua transferncia, normalmente, esta ao completa-se em menos de 48 horas. Uma
vez aprovado receber um e-mail com as instrues de download.
NOTA: Os pedidos podem ser rejeitados pelas seguintes razes

- Os dados de registo esto incompletos
- H poucos ou nenhuns detalhes sobre a utilizao prevista
- O solicitante parece ser uma empresa comercial ou um concorrente
viii
ndice
1. DO ZERO AO UM .................................................................................................................................................................................... 1
1.1. O PLANO DE JOGO ......................................................................................................................................................................................... 1
1.2. A ARTE DE GERIR A COMPLEXIDADE ............................................................................................................................................................. 2
1.3. ABSTRAO DIGITAL ..................................................................................................................................................................................... 6
1.4. BASES NUMRICAS ........................................................................................................................................................................................ 8
1.5. PORTAS LGICAS ......................................................................................................................................................................................... 23
1.6. POR BAIXO DA ABSTRAO DIGITAL ........................................................................................................................................................... 27
1.7. TRANSSTORES CMOS* ................................................................................................................................................................................ 33
1.8. CONSUMO DE ENERGIA............................................................................................................................................................................... 43
1.9. SUMRIO E ANTECIPAO .......................................................................................................................................................................... 45
2. PROJETO DE LGICA COMBINATRIA.................................................................................................................................................... 73
2.1. INTRODUO ............................................................................................................................................................................................... 73
2.2. EQUAES BOOLEANAS .............................................................................................................................................................................. 77
ix
2.3. LGEBRA BOOLEANA ................................................................................................................................................................................... 81
2.4. DA LGICA S PORTAS ................................................................................................................................................................................ 90
2.5. LGICA COMBINATRIO MULTI-NVEL ....................................................................................................................................................... 93
2.6. XS E ZS, OH MEU DEUS! ............................................................................................................................................................................. 97
2.7. MAPAS DE KARNAUGH ................................................................................................................................................................................ 99
2.8. BLOCOS COMBINATRIOS ......................................................................................................................................................................... 109
2.9. TEMPORIZAO ......................................................................................................................................................................................... 115
2.10. SUMRIO................................................................................................................................................................................................ 123
3. PROJETO DE LGICA DIGITAL .............................................................................................................................................................. 139
3.1. INTRODUO ............................................................................................................................................................................................. 139
3.2. BSCULAS E FLIP-FLOPS ............................................................................................................................................................................. 140
3.3. PROJETO DE LGICA SNCRONA ................................................................................................................................................................ 153
3.4. MQUINAS DE ESTADOS FINITOS ............................................................................................................................................................. 159
3.5. TEMPORIZAO DA LGICA SEQUENCIAL ................................................................................................................................................ 186
3.6. PARALELISMO ............................................................................................................................................................................................ 208
3.7. SUMRIO ................................................................................................................................................................................................... 213
4. LINGUAGENS DE DESCRIO DE HARDWARE ....................................................................................................................................... 231
4.1. INTRODUO ............................................................................................................................................................................................. 231
4.2. LGICA COMBINATRIA ............................................................................................................................................................................ 237
4.3. MODELAGEM ESTRUTURAL ....................................................................................................................................................................... 257
x
4.4. LGICA SEQUENCIAL ................................................................................................................................................................................. 262
4.5. MAIS LGICA COMBINATRIA .................................................................................................................................................................. 271
4.6. MQUINAS DE ESTADOS FINITOS ............................................................................................................................................................. 289
4.7. TIPOS DE DADOS* ...................................................................................................................................................................................... 297
4.8. MDULOS PARAMETRIZADOS*................................................................................................................................................................. 304
4.9. TESTBENCHES ............................................................................................................................................................................................ 310
4.10. SUMRIO................................................................................................................................................................................................ 317
5. BLOCOS DE CONSTRUO DIGITAL ...................................................................................................................................................... 339
5.1. INTRODUO ............................................................................................................................................................................................. 339
5.2. CIRCUITOS ARITMTICOS .......................................................................................................................................................................... 339
5.3. SISTEMAS NUMRICOS .............................................................................................................................................................................. 361
5.4. BLOCOS DE CONSTRUO SEQUENCIAIS .................................................................................................................................................. 368
5.5. MATRIZES DE MEMRIA............................................................................................................................................................................ 373
5.6. MATRIZES LGICAS.................................................................................................................................................................................... 386
5.7. SUMRIO ................................................................................................................................................................................................... 397
6. ARQUITETURA .................................................................................................................................................................................... 417
6.1. INTRODUO ............................................................................................................................................................................................. 417
6.2. LINGUAGEM ASSEMBLY............................................................................................................................................................................. 418
6.3. LINGUAGEM DE MQUINA........................................................................................................................................................................ 431
6.4. PROGRAMANDO ........................................................................................................................................................................................ 439
xi
6.5. MODOS DE ENDEREAMENTO .................................................................................................................................................................. 476
6.6. LUZ, CMERA, AO: COMPILANDO, MONTANDO E CARREGANDO ....................................................................................................... 480
6.7. MISCELNEA .............................................................................................................................................................................................. 489
6.8. PERSPECTIVA DO MUNDO REAL: ARQUITETURA X86 ............................................................................................................................... 496
6.9. SUMRIO ................................................................................................................................................................................................... 507
7. MICROARQUITETURA.......................................................................................................................................................................... 529
7.1. INTRODUO ............................................................................................................................................................................................. 529
7.2. ANLISE DE DESEMPENHO ........................................................................................................................................................................ 534
7.3. PROCESSADORES DE CICLO-NICO ........................................................................................................................................................... 536
7.4. PROCESSADOR MULTI-CICLO..................................................................................................................................................................... 554
7.5. PROCESSADOR COM PIPEPLINE................................................................................................................................................................. 579
7.6. REPRESENTAO HDL*.............................................................................................................................................................................. 604
7.7. EXCEES*................................................................................................................................................................................................. 621
7.8. MICROARQUITETURA AVANADA*........................................................................................................................................................... 625
7.9. PERSPECTIVA DO MUNDO REAL: MICROARQUITETURA X86* .................................................................................................................. 644
7.10. SUMRIO................................................................................................................................................................................................ 653
8. MEMRIA E SISTEMAS DE I/O ............................................................................................................................................................. 667
8.1. INTRODUO ............................................................................................................................................................................................. 667
8.2. ANLISE DA PERFORMANCE DOS SISTEMAS DE MEMRIA...................................................................................................................... 672
8.3. CACHES ...................................................................................................................................................................................................... 674
xii
8.4. MEMRIA VIRTUAL ................................................................................................................................................................................... 695
8.5. INTRODUO AO I/O ................................................................................................................................................................................. 710
8.6. SISTEMAS DE I/O EMBARCADOS ............................................................................................................................................................... 713
8.7. SISTEMAS I/O DO PC .................................................................................................................................................................................. 793
8.8. PERSPECTIVA DO MUNDO REAL: MEMRIA X86 E SISTEMAS I/O ............................................................................................................ 803
8.9. SUMRIO ................................................................................................................................................................................................... 808
A IMPLEMENTAO DE SISTEMAS DIGITAIS ........................................................................................................................................... 825
A.1 INTRODUO ............................................................................................................................................................................................. 825
A.2 LGICA 74XX .............................................................................................................................................................................................. 825
A.3 LGICA PROGRAMVEL ............................................................................................................................................................................ 827
A.4 CIRCUITOS INTEGRADOS DE USO ESPECFICO ........................................................................................................................................... 835
A.5 DATA SHEETS ............................................................................................................................................................................................. 835
A.6 FAMLIA LGICAS....................................................................................................................................................................................... 842
A.7 EMPACOTAMENTO E MONTAGEM ........................................................................................................................................................... 845
A.8 LINHAS DE TRASMISSO ............................................................................................................................................................................ 851
A.9 ECONOMIA ................................................................................................................................................................................................ 866
B INSTRUES MIPS............................................................................................................................................................................... 871
C PROGRAMAO EM C ......................................................................................................................................................................... 877
C.1 INTRODUO ............................................................................................................................................................................................. 877
C.2 BEM VINDO AO C ....................................................................................................................................................................................... 879
xiii
C.3 COMPILAO ............................................................................................................................................................................................. 881
C.4 VARIVEIS .................................................................................................................................................................................................. 885
C.5 OPERADORES ............................................................................................................................................................................................. 890
C.6 CHAMADAS DE FUNO............................................................................................................................................................................ 894
C.7 DECLARAES DE CONTROLE DE FLUXO................................................................................................................................................... 896
C.8 MAIS TIPOS DE DADOS .............................................................................................................................................................................. 902
C.9 BIBLIOTECAS PADRO ............................................................................................................................................................................... 922
C.10 COMPILADOR E OPES DA LINHA DE COMANDO .................................................................................................................................. 933
C.11 ERROS COMUNS ........................................................................................................................................................................................ 935
D PROCESSADOR MIPSFPGA ................................................................................................................................................................... 941
D.1 INTRODUO ............................................................................................................................................................................................. 941
D.2 OBTER E INSTALAR AS FERRAMENTAS DE TRABALHO .............................................................................................................................. 952
D.3 SIMULAO COM O MODELSIM ............................................................................................................................................................... 963
D.4 CARREGAR E DEPURAR UM PROGRAMA EM TEMPO REAL ...................................................................................................................... 972
xiv
xv
Prefcio
Porqu publicar mais um livro sobre projeto digital e arquitetura de computadores? H dezenas de bons
livros impressos sobre o projeto digital. H tambm vrios bons livros sobre arquitetura de computadores,
especialmente os textos clssicos de Patterson e Hennessy. Este livro nico na sua abordagem na medida
em que apresenta o projeto de lgica digital a partir da perspectiva da arquitetura de computadores,
comeando do incio com 1 e 0, e levando os alunos atravs da concepo de um microprocessador MIPS.
Temos utilizado vrias edies do Computer Organization and Design (COD) de Patterson Hennessy
durante muitos anos no Harvey Mudd College. Gostamos particularmente da cobertura da arquitetura MIPS
porque uma arquitetura de microprocessador comercialmente bem-sucedida, mas simples o suficiente
para explicar claramente e construir numa aula introdutria. Dado que a nossa disciplina no tem nenhum
pr-requisito, a primeira metade do semestre dedicada ao projeto digital, o que no coberto pelo COD.
Outras universidades tm indicado a necessidade de um livro que combine o projeto digital com a arquitetura
de computadores. Comprometermo-nos a preparar um desses livros.
Acreditamos que a construo de um microprocessador um rito especial de iniciao para estudantes de
engenharia e cincia da computao. O funcionamento interno de um processador parece quase mgico para
os no iniciados, mas revela-se simples quando cuidadosamente explicado. O projeto digital em si um tema
poderoso e emocionante. A programao em linguagem assembly revela a linguagem interna falada pelo
processador. A microarquitetura a ligao entre as partes.
Este livro adequado para uma rpida introduo, de um nico semestre para projeto da arquitetura de
computadores digitais ou para dois semestres em sequncia, dando mais tempo para digerir o material e
i
experimentar no laboratrio. O curso pode ser ensinado sem pr-requisitos. O material geralmente
ensinado nos anos iniciais do curso, mas tambm pode ser acessvel a calouros brilhantes.
Caractersticas
Este livro oferece uma srie de caractersticas especiais.
Cobertura Lado-a-Lado com SystemVerilog e VHDL
As linguagens de descrio de hardware (HDL Hardware Discreption Language) esto no centro das
prticas modernas de projeto digital. Infelizmente, os projetistas esto divididos igualmente entre as duas
linguagens dominantes, SystemVerilog e VHDL. Este livro introduz as HDL no Captulo 4, logo que projeto
lgico combinatrio e sequencial tenha sido abordado. As HDL so ento utilizadas nos Captulos 5 e 7 para
projetar blocos de construo maiores e processadores inteiros. No entanto, O Captulo 4 pode ser ignorado
e os Captulos posteriores ainda assim ficam acessveis para os cursos que optem por no cobrir HDL.
Este livro nico na sua apresentao lado-a-lado de SystemVerilog e VHDL, permitindo que o leitor
aprenda as duas linguagens. O Captulo 4 descreve os princpios que se aplicam a ambas as HDL, em seguida,
fornece a sintaxe especfica de cada linguagem e exemplos em colunas adjacentes. Este tratamento, lado-a-
lado, torna mais fcil para um instrutor escolher qualquer uma das HDL, e para o leitor a transio de uma
para a outra, quer numa aula ou em prtica profissional.
Arquitetura Clssica MIPS e Microarquitetura
Os Captulos 6 e 7 focam a arquitetura MIPS adaptada a partir da abordagem feita por Patterson e
Hennessy. A arquitetura MIPS ideal porque uma arquitetura real, entregue em milhes de produtos por
ano, no entanto, simples e fcil de aprender. Alm disso, centenas de universidades em todo o mundo tm
desenvolvido pedagogia, laboratrios, e ferramentas em torno da arquitetura MIPS.
ii
Perspectivas do Mundo Real
Os Captulos 6, 7 e 8 ilustram a arquitetura, a microarquitetura, e hierarquia de memria de processadores
Intel x86. O Captulo 8 tambm descreve os perifricos no contexto do microcontrolador PIC32 da Microchip.
Estes Captulos tm uma perspectivam do mundo real e mostram como os conceitos discutidos nos Captulos
relacionados com os chips so encontrados em muitos PC e electrnica de consumo.
Overview Acessvel de Microarquiteturas Avanadas
O Captulo 7 inclui uma viso geral das modernas caractersticas da microarquitetura de alto desempenho,
incluindo, branch prediction, superscalar e out-of-order operation, multithreading, e multicore processors. A
abordagem acessvel a um aluno num primeiro curso e mostra como as microarquiteturas do livro podem ser
estendidas a processadores modernos.
Exerccios de Fim-de-Captulo e Perguntas da Entrevista
A melhor maneira de aprender projeto digital faz-lo. Cada Captulo termina com numerosos exerccios
para praticar o material. Os exerccios so seguidos por um conjunto de perguntas de entrevista que os nossos
colegas da indstria pediram a alunos candidatos para trabalhar neste domnio. Essas perguntas fornecem uma
viso til para os candidatos vislumbrarem os problemas de trabalho normalmente encontrados no processo
de entrevista. (As solues dos exerccios esto disponveis atravs das pginas web da editora e dos
instrutores do livro. Para mais detalhes, consulte a seo seguinte, suplementos on-line.)
Suplementos Online
Os materiais complementares esto disponveis online em textbooks.elsevier.com/ 9780123944245. Este
site da editora (acessvel a todos os leitores) inclui:
Solues dos exerccios mpares
iii
Link para ferramentas profissionais de Projeto Assistido por Computador (CAD) da Altera\ e
Synopsys
Link para QtSpim (referidos genericamente como SPIM), um simulador MIPS
Cdigo HDL para o processador MIPS
Dicas teis para o Altera Quartus II
Dicas teis para o IDE da Microchip MPLAB
Slides no formato PowerPoint (PPT) do curso
Amostras de materiais do curso e de laboratrio
Errata
O site do instrutor (vinculado ao site da editora e acessvel a quem se registe em textbooks.elsevier.com)
inclui:
Solues para todos os exerccios
Link para ferramentas profissionais de Projeto Assistido por Computador (CAD) da Altera e
Synopsys. (A Synopsys oferece o Synplify Premier s universidades qualificadas num pacote de 50 licenas.
Para mais informaes sobre o programa Universitrio da Synopsys, aceder ao site do instrutor para este
livro.)
Figuras do texto em formatos JPG e PPT
Detalhes adicionais sobre como usar as ferramentas Altera, Synopsys, Microchip, e QtSpim no seu curso
so fornecidos na prxima seo. Detalhes sobre os materiais de laboratrio de amostra tambm so
fornecidos aqui.
iv
Como usar as Ferramentas de Software num Curso
Altera Quartus II
A Quartus II Web Edition uma verso gratuita da ferramenta profissional para projeto FPGA Quartus II.
Permite que os alunos carreguem os seus projetos digitais em esquema ou usando uma linguagem de descrio
de hardware (HDL) SystemVerilog ou VHDL. Depois de carregarem o projeto, os alunos podem simular os seus
circuitos usando o ModelSim - Altera Starter Edition, que est disponvel com o Altera Quartus II Web Edition.
O Quartus II Web Edition tambm inclui uma ferramenta de sntese lgica que suporta tanto o SystemVerilog
como o VHDL.
A diferena entre a Web Edition e a Subscription Edition que a Web Edition suporta um subconjunto das
FPGA mais comuns da Altera. A diferena entre o ModelSim-Altera Starter Edition e as verses comerciais do
ModelSim que a Starter Edition degrada o desempenho para simulaes com mais de 10.000 linhas de HDL.
Microchip MPLAB IDE
O MPLAB da Microchip Integrated Development Environment (IDE) uma ferramenta para programao de
microcontroladores PIC e est disponvel para download gratuito. A aplicao MPLAB integra escrita,
compilao, simulao e depurao (debug) numa nica interface. Ela inclui um compilador C e um depurador,
permitindo que os alunos possam desenvolver programas em C e assembly, compil-los e, opcionalmente,
program-los num microcontrolador PIC.
Ferramentas Opcionais: Synplify Premier e QtSpim
O Synplify Premier e o QtSpim so ferramentas opcionais que podem ser utilizadas com este material.
O produto Synplify Premier um ambiente de sntese e depurao para projeto de FPGA e CPLD. Est
includo o HDL Analyst, uma ferramenta de anlise HDL grfica nica que gera automaticamente vistas
v
esquemticas do projeto com cross-probing ao cdigo-fonte HDL. Isto extremamente til no processo de
aprendizagem e depurao.
A Synopsys oferece o Synplify Premier s universidades qualificadas num pacote de 50 licenas. Para
mais informaes sobre o programa Universitrio da Synopsys ou o software de desenho Synopsys FPGA,
visite o site instrutor deste livro (textbooks.elsevier.com/9780123944245).
O QtSpim, tambm chamado simplesmente de SPIM, um simulador MIPS que executa cdigo assembly
MIPS. Os alunos inserem o seu cdigo assembly para MIPS num arquivo de texto e executam-no usando o
QtSpim. O QtSpim exibe as instrues, a memria e os valores dos registros. Ligaes para os arquivos dos
manuais e dos exemplos do utilizador esto disponveis no site da editora
(textbooks.elsevier.com/978012394424).
Labs
O site da editora inclui links para uma srie de laboratrios que cobrem tpicos de projeto digital atravs
da arquitetura de computador. Os laboratrios ensinam os alunos como usar as ferramentas Quartus II para
introduzir, simular, sintetizar e implementar seus projetos. Os laboratrios tambm incluem tpicos na
linguagem de programao em C e assembly usando o IDE MPLAB da Microchip.
Aps a sntese, os alunos podem implementar os seus projetos usando a plataforma DE2 de
desenvolvimento e educao da Altera. Esta placa poderosa e com preos competitivos est disponvel a
partir de www.altera.com. A placa contm uma FPGA que pode ser programada para implementar os
projetos dos estudantes. Ns fornecemos laboratrios que descrevem como implementar uma seleo de
projetos na placa DE2 usando o Cyclone II Web Edition.
Para executar os laboratrios, os alunos tero de baixar e instalar o Quartus II Web Edition da Altera e
IDE MPLAB da Microchip. Os instrutores tambm podem optar por instalar as ferramentas em mquinas de
vi
laboratrio. Os laboratrios incluem instrues sobre como executar os projetos na placa DE2. A etapa de
implementao pode ser ignorada, mas ns descobrimos que possui um grande valor.
Os laboratrios foram testados no Windows, mas as ferramentas tambm esto disponveis para Linux.
Erros
Como todos os programadores experientes sabem, qualquer programa de complexidade significativa
contm, sem dvida, bugs. Assim tambm os livros. Tivemos muito cuidado para encontrar e eliminar os
erros neste livro. No entanto, alguns, sem dvida, permanecem. Iremos manter uma errata na pgina Web
do livro.
Por favor, envie os seus relatrios de erros para ddcabugs@onehotlogic.com. A primeira pessoa a relatar
um erro significativo com uma correo que usemos numa impresso futuro ser recompensada com uma
recompensa de US $1!
Agradecimentos
Em primeiro lugar agradecemos a David Patterson e John Hennessy pelo seu pioneirismo na
microarquitetura MIPS descrita em seu livro Computer Organization and Design. Temos vindo a ensinar a
partir de vrias edies do seu livro ao longo de muitos anos. Agradecemos o seu apoio gracioso deste livro
e a sua permisso para construir nas suas microarquiteturas.
Duane Bibby, o nosso cartunista favorito, trabalhou muito e bem para ilustrar a diverso e aventura do
projeto digital. Agradecemos tambm o entusiasmo de Nate McFadden, Todd Green, Danielle Miller, Dia
Robyn, e do resto da equipe do Morgan Kaufmann, que permitiu que este livro acontecesse.
vii
Gostaramos de agradecer ao Matthew Watkins que contribuiu na seo sobre multiprocessadores
Heterogneos no Captulo 7. Tambm apreciamos o trabalho de Chris Parks, Carl Pearson, e Jonathan Chai
que testaram o cdigo e desenvolveram contedo para a segunda edio.
Numerosos revisores melhoraram substancialmente o livro. Eles incluem John Barr, Jack V. Briner,
Andrew C. Brown, Carl Baumgaertner, A. Utku Diril, Jim Frenzel, Jaeha Kim, Philip King, James Pinter-Lucke,
Amir Roth, Z. Jerry Shi, James E. Stine, Luke Teyssier, Peiyi Zhao, Zach Dodds, Nathaniel Guy, Ashwin Krishna,
Volnei Pedroni, Karl Wang, Ricardo Jasinski, e um revisor annimo.
Apreciamos tambm aos alunos do nosso curso em Harvey Mudd College, que nos deram um feedback
til em esboos deste livro. Uma nota especial a Matt Weiner, Carl Walsh, Andrew Carter, Casey Schilling,
Alice Clifton, Chris Bacon, e Stephen Brawner.
E, por ltimo, mas no menos importante, ambos agradecemos s nossas famlias por seu amor e apoio.
viii
Acerca dos Autores
David Money Harris professor de engenharia no Harvey Mudd College. Recebeu seu Ph.D. em Engenharia Eltrica pela Universidade de
Stanford e seu M.Eng. em Engenharia Eltrica e Cincia da Computao pelo MIT. Antes de ingressar em Stanford, ele trabalhou na Intel como
um projetista de lgica e circuitos nos processadores Itanium e Pentium II. Desde ento, ele consultor na Sun Microsystems, Hewlett-Packard,
Evans & Sutherland, e noutras empresas de projeto. As paixes de David incluem o ensino, a construo de chips, e explorar o ar livre. Quando
no est no trabalho, ele pode ser encontrado em caminhadas, montanhismo ou escalada. Ele particularmente gosta de caminhar com os seus
trs filhos. David detm cerca de uma dzia de patentes e autor de trs outros livros de texto sobre projeto de chips, bem como quatro guias
das montanhas do sul da Califrnia.
Sarah L. Harris professora associada de engenharia no Harvey Mudd College. Recebeu seu Ph.D. e M.S. em Engenharia Elctrica pela
Universidade de Stanford. Antes de ingressar em Stanford, recebeu um B. S. em Engenharia Elctrica e da Computao pela Universidade Brigham
Young. Sarah tambm trabalhou na Hewlett-Packard, San Diego Supercomputer Center, e Nvidia. Ela ama ensinar e experimentao laboratorial.
Quando ela no est trabalhando ou correndo atrs dos seus dois filhos, pode ser encontrada a tocar msica com amigos, em caminhadas, na
canoagem, no ciclismo, e a viajar.
ix
x
Captulo um Do Zero ao Um
1. Do Zero ao Um
1.1. O PLANO DE JOGO
Os microprocessadores revolucionaram o mundo durante as ltimas trs dcadas. Um computador
porttil possui hoje mais capacidades do que no passado um mainframe do tamanho de uma sala. Um
carro topo de linha possui cerca de 50 microprocessadores. Os avanos nos microprocessadores tornaram
os telefones celulares e a internet possveis., melhoraram vastamente a medicina, e transformaram a
forma como a guerra travada. As vendas na indstria mundial dos semicondutores cresceram dos $21
bilhes de US em 1985 para os $300 bilhes em 2011, sendo os microprocessadores um segmento
importante destas vendas. Acreditamos que os microprocessadores no so apenas tecnicamente,
economicamente, e socialmente importantes, mas so tambm uma inveno humana intrinsecamente
fascinante. No momento em que o leitor acabar de ler este livro, ele saber como projetar e construir um
microprocessador. As capacidades que o leitor ir adquirir ao longo do caminho vo permitir-lhe projetar
outros sistemas digitais.
Assume-se que o leitor est basicamente familiarizado com conhecimentos de eletricidade,
experincia prvia em programao, e um interesse genuno em perceber o funcionamento de um
computador. Este livro foca-se no projeto de sistemas digitais, que funcionam em termos de 1 e 0.
Comea-se por estudar o funcionamento de portas de lgica digital, que aceitam 1 e 0 como entradas, e
devolvem na sua sada 1 e 0 como resultado. Em seguida, explorada a forma de combinar portas lgicas
em mdulos de maior complexidade tais como somadores ou memrias. Transita-se em seguida para a
programao em linguagem assembly, que a lngua nativa do microprocessador. Finalmente, a
associao de portas lgicas vai permitir construir um microprocessador que executa essa linguagem
assembly.
1
Uma grande vantagem dos sistemas digitais que os blocos utilizados na sua construo so muito
simples: apenas 1 e 0. No requerem matemtica complexa ou um conhecimento aprofundado de
fsica. Em vez disso, o desafio do projetista passa por combinar estes blocos simples em sistemas de
complexidade crescente. Um microprocessador pode ser o primeiro sistema que o leitor constri que
demasiado complexo para ser por ele interiorizado. Um dos temas abordados neste livro a gesto
da complexidade.
1.2. A ARTE DE GERIR A COMPLEXIDADE

Uma das caractersticas que separa um engenheiro ou cientista da computao de um leigo uma
abordagem sistemtica da gesto da complexidade. Os modernos sistemas digitais so construdos a
partir de milhes ou bilhes de transistores. Nenhum ser humano pode compreender estes sistemas
escrevendo equaes que descrevem o movimento dos eltrons em cada transistor e resolver todas
essas equaes simultaneamente. O leitor ter que aprender a gerir a complexidade para perceber
como construir um microprocessador sem se atolar num pntano de detalhes.
1.2.1. Abstrao
Uma tcnica fundamental para gerenciar a complexidade a abstrao: Escondendo os detalhes
sempre que eles no sejam relevantes. Um sistema pode ser visto de diferentes nveis de abstrao.
Por exemplo, os polticos abstraem-se do mundo em cidades, municpios, estados e pases. Um
municpio contm vrias cidades e um estado contm muitos municpios. Quando um poltico est
concorrendo presidncia, o poltico est principalmente interessado em saber como o estado ir
votar, em vez de saber como cada municpio ir votar, de modo que o estado um nvel mais til de
2
abstrao. Por outro lado, o Instituto de Estatstica mede a populao de cada cidade, por isso, esta
agncia deve considerar os detalhes associados a um menor nvel de abstrao.
A Figura 1.1 ilustra os nveis de abstrao de um sistema computacional eletrnico, juntamente
com blocos de construo tpicos em cada nvel. No nvel mais baixo de abstrao temos a fsica, o
movimento dos eltrons. O comportamento dos eltrons descrito atravs da mecnica quntica e
das equaes de Maxwell. O nosso sistema construdo a partir de dispositivos eletrnicos, como
transstores (ou tubos de vcuo, era uma vez). Estes dispositivos tm bem definidos pontos de
ligao chamados terminais e podem ser modelados atravs da relao observada entre a tenso e
a corrente medida em cada terminal. Ao abstrair a este nvel do dispositivo, podemos ignorar os
eltrons individuais. O prximo nvel de abstrao corresponde aos circuitos analgicos, em que os
dispositivos so montados para criar componentes, tais como os amplificadores. Os circuitos
analgicos possuem uma faixa contnua de tenses de entrada e sada. Os circuitos digitais, tais como
as portas lgicas, esto limitados a tenses pertencentes a intervalos discretos, que usaremos para
indicar os nveis 0 e 1. No projeto de sistemas lgicos, vamos construir estruturas mais complexas,
como somadores ou memrias, utilizando circuitos digitais.
A microarquitetura liga os nveis de abstrao lgica com a arquitetura. O nvel de abstrao da
arquitetura descreve o computador do ponto de vista do programador. Por exemplo, a arquitetura
Intel x86 utilizada por microprocessadores, na maioria dos computadores pessoais (PC) definida Figura 1.1 Nveis de abstrao para
um sistema computacional
por um conjunto de instrues e registros (memria para armazenar temporariamente variveis) que
electrnico
o programador est autorizado a usar. A microarquitetura envolve a combinao de elementos
lgicos para executar as instrues definidas na arquitetura. Uma arquitetura particular pode ser
implementada por uma de vrias microarquiteturas diferentes, com diferentes relaes de
preos/desempenhos/potncia. Por exemplo, o processador Intel Core i7, o Intel 80486, e o AMD
Athlon todos implementam a arquitetura x86 com diferentes microarquiteturas.
Entrando no reino do software, o sistema operacional lida com detalhes de baixo nvel, tais como
o acesso a uma unidade de disco rgido ou a gesto da memria. Finalmente, os aplicativos usam
essas facilidades oferecidas pelo sistema operacional para resolver um problema para o utilizador.
3
Cada Captulo deste livro comea com um Graas ao poder de abstrao, a sua av pode navegar na Web sem qualquer preocupao pelas
cone de abstrao indicando o foco do vibraes qunticas dos eltrons ou a organizao da memria no computador dela.
Captulo em azul-escuro, com temas
Este livro centra-se nos nveis de abstrao dos circuitos digitais atravs da arquitetura de
secundrios mostrados em tons mais
claros de azul.
computadores. Quando o leitor trabalha num nvel de abstrao, bom saber algo sobre os nveis de
abstrao imediatamente acima e abaixo de onde ele est a trabalhar. Por exemplo, um cientista da
computao no pode otimizar completamente o cdigo sem compreender a arquitetura para a qual o
programa est a ser escrito. Um engenheiro de dispositivos no pode optar por solues de compromisso
no projeto de um transstor sem compreender os circuitos em que sero utilizados os transstores.
Esperamos que ao terminar de ler este livro, o leitor possa escolher o nvel de abstrao adequado para
resolver o seu problema e avaliar o impacto das suas escolhas de projeto noutros nveis de abstrao.
1.2.2. Disciplina
Disciplina o ato de restringir intencionalmente as suas escolhas de projeto para que se possa
trabalhar de forma mais produtiva num nvel mais alto de abstrao. A utilizao de peas intermutveis
uma aplicao familiar de disciplina. Um dos primeiros exemplos de peas intermutveis foi na
fabricao da espingardas de pederneira. At o incio do sculo IXX, as espingardas eram fabricadas
individualmente mo. Os componentes adquiridos a vrios artesos eram cuidadosamente
armazenados e montados por um armeiro altamente qualificado. A disciplina de peas intermutveis
revolucionou a indstria. Ao limitar os componentes a um conjunto padronizado com tolerncias bem
definidas, as espingardas passaram a poder ser montadas e reparadas muito mais rapidamente e com
menos habilidade. O armeiro deixou de se preocupar com os nveis mais baixos de abstrao, tais como
a forma especfica individual de um cano ou coronha.
No contexto deste livro, a disciplina digital ser muito importante. Os circuitos digitais utilizam
tenses discretas, enquanto os circuitos analgicos usam tenses contnuas. Por conseguinte, os
circuitos digitais so um subconjunto dos circuitos analgicos e em certo sentido, devem ser mais
limitados do que a classe mais ampla de circuitos analgicos. No entanto, os circuitos digitais so muito
mais simples de projetar.
Ao nos limitarmos aos circuitos digitais podemos facilmente combinar componentes em sistemas
sofisticados que, em ltima anlise, superam aqueles construdos a partir de componentes analgicos
4
em muitas aplicaes. Por exemplo, televisores digitais, discos compactos (CD) e telefones celulares
O Capito Meriwether Lewis da Lewis and
substituem atualmente os seus antecessores analgicos.
Clark Expedition foi um dos primeiros
1.2.3. Os Trs Y defensores de peas intercambiveis para
Alm da abstrao e da disciplina, os projetistas utilizam os trs "y" para gerir a complexidade: espingardas. Em 1806, ele explicou:
hierarquia, modularidade e regularidade. Estes princpios aplicam-se tanto a sistemas de software As armas de Drewyer e do Sarg. Pryor
como de hardware. ficaram ambas fora de servio. A primeira
foi reparada com um trico novo, o antigo
A hierarquia implica a diviso de um sistema em mdulos, em seguida, deve-se ainda
tornou-se imprprio para uso; a segunda
subdividir cada um destes mdulos at que as peas sejam fceis de entender.
teve o co quebrado, que foi substitudo
A modularidade afirma que os mdulos tm funes e interfaces bem definidas, para que por uma cpia que havia sido preparada
se possam interligar facilmente sem imprevistos efeitos colaterais. para o trinco em Harpers Ferry, onde foi
A regularidade procura uniformidade entre os mdulos. Os mdulos mais comuns so fabricada. Mas pela precauo tomada
reutilizados muitas vezes, reduzindo o nmero de mdulos distintos que devem ser em trazer esses trincos extras, e as peas
concebidos. de trincos, alm da ingenuidade de John
Shields, a maioria das nossas armas
Para ilustrar esses "y" voltamos ao exemplo da fabricao das espingardas. Uma espingarda de estaria, neste momento, totalmente
pederneira foi um dos objetos mais intrincados de uso comum no incio do sculo IXX. Utilizando o inadequadas para uso; mas felizmente
princpio da hierarquia, podemos dividi-lo em componentes como mostrado na Figura 1.2: trinco, para ns, eu tenho-as aqui comigo para
coronha e cano. registrar que todas elas esto em boa
ordem.
Veja Elliott Coues, ed, a histria de Lewis

e Clark Expedition ... (4 vols), New York:
Harper, 1893;. reimpresso, 3 vols, New
York: Dover, 3: 817.
5
Figura 1.2 Espingarda Flintlock com

uma vista detalhada (Image by
Euroarms Italia. www.euroarms.net
2006.)
Charles Babbage, 1791-1871.
Frequentou a Universidade de Cambridge 1.3. ABSTRAO DIGITAL

e casou-se com Georgiana Whitmore em
1814. Inventou a Mquina Analtica, o A maioria das variveis fsicas contnua. Por exemplo, a tenso de um fio, a frequncia de oscilao, ou
primeiro computador mecnico do a posio de uma massa so todas quantidades contnuas. Os sistemas digitais, por outro lado, representam
mundo. Tambm inventou o cowcatcher
informaes com variveis de valores discretos, ou seja, variveis com um nmero finito de valores distintos.
e a taxa postal universal e a gazua,
(Imagem cortesia da Fourmilab Sua,
www.fourmilab.ch).
6
Um sistema digital inicial que utilizava variveis com dez valores discretos era a Mquina
Analtica de Charles Babbage. Babbage trabalhou de 1834 a 1871, na concepo e tentando
construir este computador mecnico. A Mquina Analtica utilizava engrenagens com dez posies
marcadas de 0 a 9, como um velocmetro mecnico num carro. A Figura 1.3 mostra um prottipo
da Mquina Analtica, na qual cada linha processa um dgito. Babbage optou por 25 linhas de
engrenagens, a mquina possui por isso 25 dgitos de preciso.
Figura 1.3 Mquina Analtica de

Babbage, em construo por altura
da sua mortem 1871 (Imagem
cortesia do Science Museum/Science
and Society Picture Library)
Ao contrrio da mquina de Babbage, a maioria dos computadores electrnicos usa uma

representao binria (dois valores) na qual uma tenso alta indica um "1" e uma tenso baixa
indica um "0", uma vez que mais fcil de distinguir entre duas tenses do que entre dez.
A quantidade de informao D numa varivel discreta avaliada com n estados distintos medida
em unidades de bits como
= log 2 (1.1)
Uma varivel binria transmite log2(2) = 1 bit de informao. Na verdade, a palavra bit deriva de
dgito binrio. Cada uma das engrenagens de Babbage permitia log2(10) = 3.322 bits de informao,
pois poderia estar numa das 23.322 = 10 posies. Um sinal contnuo contm teoricamente uma
7
quantidade infinita de informao, porque pode assumir um nmero infinito de valores. Na prtica, o rudo
e o erro de medio limitam as informaes a apenas 10 a 16 bits para a maioria dos sinais contnuos. Se
a medio tem de ser feita rapidamente, o contedo de informao inferior (por exemplo, 8 bits).
Este livro centra-se em circuitos digitais que utilizam variveis binrias: 1 e 0. George Boole desenvolveu
um sistema de lgica de funcionamento tendo por base variveis binrias que agora conhecido como
lgica booleana. Cada uma das variveis de Boole pode assumir o valor TRUE ou FALSE. Os computadores
electrnicos geralmente usam uma tenso positiva para representar '1' e zero volts para representar '0'.
Neste livro, vamos usar os termos '1', TRUE, e HIGH como sinnimos. Da mesma forma, vamos usar '0',
FALSE, e LOW de forma intermutvel.
A beleza da abstrao digital que os projetistas digitais podem-se concentrar nos 1 e 0, ignorando se
as variveis booleanas so fisicamente representadas com tenses especficas, engrenagens rotativas, ou
mesmo atravs de nveis de fluido hidrulico.
Um programador de computadores pode trabalhar sem a necessidade de conhecer os detalhes ntimos
de hardware do computador. Por outro lado, a compreenso dos detalhes do hardware permite ao
programador otimizar o software para esse computador especfico.
Um bit isolado no carrega muita informao. Na prxima seo examinamos como grupos de bits
podem ser usados para representar nmeros. Nos prximos Captulos, vamos tambm utilizar grupos de
bits para representar letras e programas.
1.4. BASES NUMRICAS

O leitor est acostumado a trabalhar com nmeros decimais. Nos sistemas digitais que consistem em 1
e 0, os nmeros binrios ou hexadecimais so muitas vezes mais convenientes. Esta seo apresenta os
diversos sistemas numricos que sero utilizados em todo o resto do livro.
8
Figura 1.4 Representao de um

nmero decimal
1.4.1. Nmeros Decimais

Na escola primria, o leitor aprendeu a contar e a fazer contas em decimal. Assim como o leitor
(provavelmente) tem dez dedos, h dez dgitos decimais: 0, 1, 2, ..., 9. Os dgitos decimais so associados
para formar nmeros decimais maiores. Cada posio de um dgito decimal tem dez vezes o peso da posio
anterior. Da direita para a esquerda, os pesos das posies so 1, 10, 100, 1000, e assim por diante. Os
nmeros decimais so referidos como base 10. A base indicada por um subscrito aps o nmero para
evitar a confuso quando se trabalha com mais do que uma base. Por exemplo, a Figura 1.4 mostra a forma
como o nmero decimal 974210 escrito como a soma de cada um dos seus dgitos multiplicado pelo peso
da posio correspondente.
Um nmero decimal de N-dgitos representa uma das possibilidades 10N: 0, 1, 2, 3, ..., 10N - 1. Esta
chamada a gama do nmero. Por exemplo, um nmero de trs dgitos decimais representa uma das 1000
possibilidades na faixa de 0 a 999.
1.4.2. Nmeros Binrios
Os bits representam um de dois valores, 0 ou 1, e so associados para formar nmeros binrios. Cada
posio de um nmero binrio tem o dobro do peso da posio anterior, assim os nmeros binrios tm
base 2. No sistema binrio, o peso da posio (mais uma vez da direita para a esquerda) 1, 2, 4, 8, 16, 32,
64, 128,256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, e assim por diante. Se o leitor trabalha
com nmeros binrios, muitas vezes, vai economizar tempo se se lembrar dessas potncias de dois at 216.
Um nmero binrio de N-bit representa uma das possibilidades 2N: 0, 1, 2, 3, ..., 2N-1. A Tabela 1.1 mostra
os 1, 2, 3, e 4 bits de nmeros binrios e os seus equivalentes decimais.
9
Exemplo 1.1 CONVERSO DE BINRIO PARA DECIMAL

Converter o nmero binrio 101102 para decimal.
Soluo: A Figura 1.5 ilustra o processo de converso.
Tabela 1.1 Nmeros binrios e o seu equivalente decimal
10
Figura 1.5 Converso de um nmero

binrio para decimal
Exemplo 1.2 CONVERSO DE DECIMAL PARA BINRIO

Converter o nmero decimal 8410 para binrio.
Soluo: Determinar se cada posio do resultado binrio tem um 1 ou um 0. Podemos fazer isso a
partir da esquerda ou da direita.
Trabalhando a partir da esquerda, comeamos com a maior potncia de 2 menor do que ou igual ao
nmero (neste caso, 64). 84 64, para que haja um 1 na posio do 64, restando 84-64 = 20. 20 < 32,
para que haja um 0 na posio do 32. 20 16, para que haja um 1 na posio do 16, deixando 20-16 =
4. 4 <8, para que haja um 0 na posio do 8. 4 4, para que haja um 1 na posio do 4, deixando 4-4 =
0. Assim, deve haver 0 de na posio do 2 e primeira posio. Colocando tudo junto, temos que 8410 =
10101002.
Trabalhar a partir da direita, repetidamente devemos dividir o nmero por 2. O resto vai para a
posio. 84/2 = 42, ento 0 vai para a posio do 1. 42/2 = 21, ento 0 vai para a posio do 2. 21/2 =
10 com um resto de 1 indo para posio do 4. 10/2 = 5, por isso 0 fica na posio do 8. 5/2 = 2 com um
resto de 1 indo para a posio do 16. 2/2 = 1, ento 0 vai para a posio do 32. Finalmente, 1/2 = 0 com
um resto de 1 indo para a coluna do 64. Novamente, temos 8410 = 10101002,
1.4.3. Nmeros Hexadecimais

Escrever nmeros binrios longos entediante e propenso a erros. Um grupo de quatro bits
representa uma de 24 = 16 possibilidades. Por isso, s vezes, mais conveniente trabalhar na base 16,
11
chamada de hexadecimal. Os nmeros hexadecimais utilizam os dgitos de 0 a 9, juntamente com as

"Hexadecimal", um termo cunhado pela letras A a F, como se mostra na Tabela 1.2. As posies na base 16 tm pesos de 1, 16, 162 (ou 256),
IBM em 1963, deriva do grego hexi (seis) e
163 (ou 4096), e assim por diante.
do Latim decem (dez). Um termo mais
adequado seria usar o termo do Latim
sexa (seis), mas sexadecimal soava muito
picante. Exemplo 1.3 CONVERSO DE HEXADECIMAL PARA BINRIO E DECIMAL
Converter o nmero hexadecimal 2ED16 para binrio e decimal.
Soluo: A converso de hexadecimal para binrio fcil, porque cada dgito hexadecimal
corresponde diretamente a quatro dgitos binrios. 216 = 00102, E16 = 11102 e D16 = 11012, de modo
que 2ED16 = 0010111011012. A converso para decimal requer o uso da aritmtica mostrada na Figura
1.6.
Figura 1.6 Converso de um nmero

hexadecimal para binrio
Exemplo 1.4 CONVERSO DE BINRIO PARA HEXADECIMAL

Converter o nmero binrio 11110102 para hexadecimal.
Soluo: Novamente, a converso fcil. Devemos comear a ler partindo da direita. Os quatro bits
menos significativos so 10102 = A16. Os prximos bits so 1112 = 716. Da o resultado ser 11110102 =
7A16.
12
Tabela 1.2 Sistema numrico hexadecimal
Exemplo 1.5 CONVERSO DE DECIMAL PARA HEXADECIMAL E BINRIO

Converter o nmero decimal 33310 para hexadecimal e binrio.
Soluo: Como na converso de decimal para binrio, a converso hexadecimal pode ser feita a partir
da esquerda ou da direita.
Trabalhando a partir da esquerda, devemos comear com a maior potncia de 16 a menos do que
ou igual ao nmero (neste caso, 256). 256 vai para 333 uma vez, para que haja um 1 na coluna 256,
13
deixando 333-256 = 77. 16 vai para 77 quatro vezes, por isso temos um 4 na posio do 16, deixando
77-16 4 = 13. 1310 = D16, para que haja um D na posio do 1. Em resumo, 33310 = 14D16. Agora fcil
converter de hexadecimal para binrio, devemos proceder como no Exemplo 1.3, resulta 14D16 =
1010011012.
Trabalhando a partir da direita, devemos repetidamente dividir o nmero por 16. O resto da diviso
fica nas respectivas posies. 333/16 = 20 com um resto de 1310 = D16 indo para a posio do 1. 20/16
= 1 com um resto de 4 indo para a coluna 16. 1/16 = 0 com um resto de 1 para a posio do 256. Mais
uma vez, o resultado 14D16.
Um microprocessador um processador 1.4.4. Bytes, Nibbles, e All That Jazz
construdo num nico chip. At dcada
Um grupo de oito bits chamado de byte. Ele representa uma de 2 8 = 256 possibilidades. O
de 1970, os processadores eram
tamanho de objetos armazenados na memria do computador habitualmente medido em bytes em
demasiado complexos para caber num
vez de bits.
nico chip, por isso processadores de
mainframe foram construdos a partir de Um grupo de quatro bits, ou metade de um byte, chamado de nibble. Ele representa uma de 24 =
placas contendo muitas fichas. A Intel 16 possibilidades. Um dgito hexadecimal ocupa um nibble e dois dgitos hexadecimais ocupam um
lanou o primeiro microprocessador de 4-
byte inteiro. Nibbles j no uma unidade usada comumente, mas o termo bonito.
bits, chamado de 4004, em 1971. Agora,
at mesmo os supercomputadores mais Os microprocessadores lidam com pedados de dados chamados de palavras. O tamanho de uma
sofisticados so construdos usando palavra depende da arquitetura do microprocessador. Quando este Captulo foi escrito em 2012, a
microprocessadores. Usaremos os termos maioria dos computadores tinham processadores de 64-bits, o que indica que eles operam palavras
microprocessador e processador de forma de 64-bits. Na poca, os computadores mais velhos processavam palavras de 32 bits tambm estavam
intercambivel ao longo deste livro.
amplamente disponveis. Os microprocessadores mais simples, especialmente os utilizados em
dispositivos tais como torradeiras, usam palavras de 8 ou 16-bits.
Num grupo de bits, o bit na posio 1 chamado de bit menos significativo (lsb less significative
bit), e ao bit na outra extremidade d-se a designao de bit mais significativo (msb - most significative
bit), como mostrado na Figura 1.7 (a) para um nmero binrio de 6-bits. Do mesmo modo, dentro de
uma palavra, os bytes so identificados como byte menos significativo (LSB - Less Significative Byte) e
de byte mais significativo (MSB - Most Significative Byte), como mostrado na Figura 1.7 (b) para um
nmero de 4-bytes escrito com oito dgitos hexadecimais.
14
Por coincidncia, 210 = 1024 103. Assim, o termo quilo (grego para mil) indica 210. Por exemplo, 210
bytes um kilobyte (1 KB). Da mesma forma, o Mega (milhes) indica 2 20 106, e giga (bilhes) indica
230 109. Se o leitor souber que 210 1000, 220 1 milho, 230 1 bilho, e se conhecer as potncias
de dois at 29, para ele fcil estimar mentalmente qualquer potncia de dois.
Figura 1.7 Byte menos e mais significante
Exemplo 1.6 ESTIMAO DE UMA POTNCIA DE DOIS

Encontrar o valor aproximado de 224 sem utilizar uma calculadora.
Soluo: Devemos dividir o expoente em mltiplos de dez com o resto. 224 = 220 24. 220 1 milho.
24 = 16. Assim, 224 16 milhes. Tecnicamente, 224 = 16.777.216, mas 16 milhes perto o suficiente.
1.4.5. Adio Binria

A adio binria semelhante adio decimal, mas mais fcil, como mostrado na Figura 1.8. Tal
como na soma decimal, se a soma dos dois nmeros maior do que o que se encaixa num nico dgito,
transportamos o valor 1 para a prxima posio. Na Figura 1.8 feita a comparao entre a adio de
nmeros decimais e nmeros binrios. Na coluna mais direita da Figura 1.8 (a), 7 + 9 = 16, o que no
pode caber num nico dgito porque ele maior do que 9. Portanto, guardamos o primeiro dgito, 6,
e transportamos as dezenas, 1, para a posio seguinte. Da mesma forma, em binrio, se a soma de
dois nmeros maior do que 1, o segundo dgito transportado para a posio seguinte. Por exemplo,
na coluna mais direita da Figura 1.8 (b), a soma 1 + 1 = 210 = 102 no cabe num nico dgito binrio.
Ento, guardamos o primeiro dgito (0) e transportamos o segundo dgito (1) do resultado para a
prxima posio. Na segunda posio, a soma de 1 + 1 + 1 = 310 = 112. Novamente, devemos guardar
15
o primeiro dgito (1) e transportar o segundo dgito (1) para a prxima posio. Por razes bvias, o bit
que transportado para a posio vizinha chamado de bit de transporte.
Figura 1.8 Exemplo de adio com transportes: (a) decimal, (b) binrio
Exemplo 1.7 SOMA BINRIA

Encontrar 01112 + 01012.
Soluo: A Figura 1.9 mostra que o valor da soma 11002. Os transportes so indicados a azul.
Figura 1.9 Exemplo de uma soma Podemos verificar o nosso trabalho, repetindo a operao em decimal. 01112 = 710. 01012 = 510. A soma
binria 1210 = 11002.
Os sistemas digitais geralmente operam com um nmero fixo de dgitos. Diz-se que a adio
transborda (overflow) se o resultado for muito grande para caber nos dgitos disponveis. Um nmero
de 4 bits, por exemplo, permite valores no intervalo [0, 15]. A adio binria de 4-bits transborda se o
resultado for superior a 15. O quinto bit descartado, produzindo um resultado incorreto nos
restantes quatro bits. A situao de overflow pode ser detectada atravs da verificao de um
transporte para fora da posio mais significativa.
Exemplo 1.8 SOMA COM OVERFLOW

Encontrar 11012 + 01012. Ocorre um overflow?
16
Soluo: A Figura 1.10 representa que a soma 100102. Este resultado transborda do intervalo de um
nmero binrio de 4-bits. Se tiver de ser armazenado como quatro bits, o bit mais significativo
descartado, deixando o resultado incorreto de 00102. Se o clculo foi feito usando nmeros com cinco
ou mais bits, o resultado teria sido 100102 corretamente representado.
1.4.6. Nmeros Binrios com Sinal Figura 1.10 Exemplo de uma soma
At agora, temos considerado apenas nmeros binrios sem sinal que representam quantidades binria com overflow
positivas. Muitas vezes, queremos representar nmeros positivos e negativos, o que requer um
sistema numrico binrio diferente. Existem vrios esquemas para representar nmeros binrios com
sinal; os dois mais amplamente empregados so chamados de sinal/magnitude e complemento-2.
Nmeros Sinal/ Magnitude
Nmeros sinal/magnitude so intuitivamente atraentes porque eles seguem o nosso costume de
escrever nmeros negativos usando um sinal de menos seguido pela magnitude. Um nmero
sinal/magnitude de N-bit usa o bit mais significativo como sinal e os restantes N-1 bits como a
magnitude (valor absoluto). Um bit de sinal de 0 indica um valor positivo e um bit de sinal de 1 indica
um valor negativo.
Exemplo 1.9 NMEROS DE SINAL/MAGNITUDE

Escreva 5 e -5 como um nmero sinal/magnitude de 4 bits
Soluo: Ambos os nmeros tm uma magnitude de 510 = 1012. Assim, 510 = 01012 e -510 = 11012.
Infelizmente, a adio binria normal no funciona para nmeros de sinal/magnitude. Por exemplo,
a adio normal de -510 + 510 d 11012 + 01012 = 100102, o que no faz sentido.
Um nmero sinal/magnitude de N-bit abrange a gama [-2-N-1 + 1, 2N-1 - 1]. Os nmeros sinal/magnitude
so um pouco estranhos j que tanto 0 como -0 existem. Ambos indicam o valor zero. Como o leitor
pode esperar, pode ser problemtico ter duas representaes diferentes para o mesmo nmero.
17
Nmero em complemento-2
O foguete de 7 bilhes de USD Ariane 5,
lanado em 4 de Junho de 1996, saiu da Os nmeros representados no formato complemento-2 so idnticos aos nmeros binrios sem sinal,
sua rota 40 segundos aps o lanamento, exceto que a posio do bit mais significativo tem um peso de -2-N-1, em vez de 2N-1. Esta representao
partiu-se, e explodiu. O problema foi ultrapassa as limitaes dos nmeros sinal/magnitude: o zero tem uma representao nica e a adio
causado quando o computador que comum funciona.
controla o foguete sofreu um overflow da
sua gama de 16 bits e crashou. O cdigo Em representao de complemento-2, o zero escrito como todos os zeros: 00 ... 0002. O nmero
tinha sido extensivamente testado no mais positivo tem um 0 na posio mais significativa e 1 de outras posies: 01 ... 1112 = 2N-1 - 1. O
foguete Ariane 4. No entanto, o Ariane 5 nmero mais negativo tem um 1 na posio mais significativa e 0 noutras posies: 10 ... 0002 = -2-N-1. O
tinha um motor mais rpido que produziu valor -1 escrito com todos os bits a 1: 11 ... 1112.
valores maiores para o computador de
controlo, que levou ao overflow. Note-se que os nmeros positivos tm um 0 na posio do bit mais significativo e os nmeros
negativos tm um 1 na posio do bit menos significativo, de modo que o bit mais significativo pode ser
visto como o bit de sinal. No entanto, os restantes bits so interpretados de forma diferente para
nmeros complemento-2 e nmeros de sinal/magnitude.
O sinal de nmero de complemento-2 revertido num processo chamado obter o complemento-2.
Este processo consiste em complementar todos os bits do nmero, seguida da soma de 1 posio do
bit menos significativo. Isto til para encontrar a representao de um nmero negativo, ou para
determinar a magnitude de um nmero negativo.
Exemplo 1.10 REPRESENTAO DE UM NMERO NEGATIVO EM COMPLEMENTO-2

Obter a representao de -210 em complemento-2 num formato de 4-bits
Soluo: Comece com + 210 = 00102. Para obter -210, inverta os bits e adicione 1. A inverso 00102 produz
11012. Sendo 11012 + 1 = 11102. Assim -210 11102.
(Fotografia cortesia da
ESA/CNES/ARIANESPACEService Optique CS6.)
18
Exemplo 1.11 VALOR DE NMEROS NEGATIVOS EM COMPLEMENTO-2

Determinar o valor decimal do nmero em complemento-2 10012.
Soluo: O nmero 10012 inicia por 1, por isso deve ser negativo. Para encontrar a sua magnitude,
devemos inverter os bits e adicionar 1. Inverso 10012 = 01102. 01102 + 1 = 01112 = 710. Assim, 10012
= -710.
Os nmeros em complemento-2 tm a vantagem de que a adio funciona corretamente tanto para

os nmeros positivos como negativos. Devemos recordar que, aquando da adio de nmeros de N-
bits, o Nsimo bit de transporte (i.e., o bit N + 1 do resultado) descartado.
Exemplo 1.12 ADICIONAR DOIS NMEROS EM COMPLEMENTO-2

Determine (a) -210 + 110 e (b) -710 + 710 usando nmeros de complemento-2.
Soluo: (a) -210 + 110 = 11102 + 00012 = 11112 = -110. (B) -710 + 710 = 10012 +
01112 = 100002. O quinto bit descartado, deixando o resultado de 4 bits correto 00002.
A subtrao realizada tomando o complemento-2 do segundo nmero seguida da adio.
Exemplo 1.13 SUBTRAIR DOIS NMEROS EM COMPLEMENTO-2

Determine (a) 510 - 310 e (b) 310 - 510 usando nmeros de 4-bits em complemento-2.
Soluo: (a) 310 = 00112. Tome o complemento-2 para obter -310 = 11012. Agora devemos adicionar 510
+ (-310) = 01012 + 11012 = 00102 = 210. Note que o transporte da posio mais significativa descartado
porque o resultado armazenado em quatro bits.
(b) Tome o complemento-2 de 510 para obter -510 = 10112. Agora adicione 310 + (-510) = 00112 + 10112
= 11102 = -210.
19
O complemento-2 de 0 encontrado invertendo todos os bits (produzindo 11 ... 111 2) e

adicionando 1, o que produz todos os bits 0, desconsiderando o transportar para fora da posio do
bit mais significativo. Por isso, o zero sempre representado com todos os bits 0. Ao contrrio do
sistema sinal/magnitude, o sistema complemento-2 no tem uma representao separado -0. O zero
considerado positivo porque o seu bit de sinal 0.
Como os nmeros sem sinal, os nmeros de complemento-2 de N-bit representam um dos 2N
possveis valores. No entanto, os valores so divididos entre nmeros positivos e negativos. Por
exemplo, um nmero sem sinal de 4-bits representa 16 valores: 0 a 15. Um nmero de 4-bits em
complemento-2 tambm representa 16 valores: -8 a 7. Em geral, o intervalo dos nmeros de N-bits
em complemento-2 est dentro do intervalo [- 2N-1, 2N-1 - 1]. Far sentido que haja mais um nmero
negativo do que nmeros positivos porque no h -0. O nmero mais negativo 10 ... 0002 = -2-N-1
s vezes chamado de nmero estranho. O complemento-2 encontrado invertendo os bits
(produzindo 01 ... 1112) e adicionando 1, que produz 10 ... 0002, o nmero estranho, novamente.
Assim, este nmero negativo no tem contrapartida positiva.
A adio de dois nmeros positivos ou nmeros negativos de N-bits pode causar overflow se o
resultado maior do que 2N-1 -1 ou inferior a -2-N-1. A adio de um nmero positivo a um nmero
negativo nunca causa overflow. Ao contrrio dos nmeros sem sinal, um transporte para fora da
coluna mais significativa no indica overflow. Em vez disso, o overflow ocorre se os dois nmeros
que esto sendo adicionados tm o mesmo bit de sinal e o resultado tem o bit de sinal oposto.
Exemplo 1.14 ADICIONAR DOIS NMEROS EM COMPLEMENTO-2 COM OVERFLOW

Determine 410 + 510 usando nmeros de 4-bits em complemento-2. Ocorre um overflow do
resultado?
Soluo: 410 + 510 = 01002 + 01012 = 10012 = -710. O resultado ultrapassa o intervalo dos nmeros
positivos de 4 bits em complemento-2, produzindo um resultado negativo incorreto. Se o clculo for
realizado usando cinco ou mais bits, o resultado 010012 = 910 teria sido correto.
20
Quando um nmero em complemento-2 estendido para mais bits, o bit de sinal deve ser copiado
para as posies de bit mais significativas. Este processo chamado de extenso de sinal. Por exemplo,
os nmeros 3 e -3 so escritos como nmeros de 4-bits em complemento-2 como 00112 e 11012,
respectivamente. A sua extenso de sinal para sete bits, ocorre copiando o bit de sinal para os trs
novos bits superiores para formar 00000112 e 11111012, respectivamente.
Comparao dos Sistemas Numricos
Os trs sistemas de nmeros binrios mais utilizados so sem sinal, complemento-2, e
sinal/magnitude. A Tabela 1.3 compara o intervalo de nmeros de N-bits em cada um destes trs
sistemas. Os nmeros em complemento-2 so convenientes porque representam inteiros positivos e
negativos e, por causa disso, a operao de soma normal funciona para todos os nmeros. A subtrao
realizada negando o segundo nmero (i.e., efetuando o complemento-2), e ento efetuando a
adio. A menos que indicado de outra forma, devemos assumir que todos os nmeros binrios
utilizam a representao em complemento-2.
Tabela 1.3 Intervalo de nmeros de N-bits
21
Figura 1.11 Linha numrica e codificao binria de 4-bits
A Figura 1.11 apresenta uma linha de nmero que indica os valores de nmeros de 4-bits em
cada um dos sistemas. Os nmeros sem sinal abrangem o intervalo [0, 15]. Os nmeros em
complemento-2 cobrem o intervalo [-8, 7]. Os nmeros positivos [0, 7] compartilham a mesma
codificao como nmeros sem sinal. Os nmeros negativos [-8, -1] so codificados de tal modo
que o maior valor binrio sem sinal representa um nmero mais prximo de 0. Note que o nmero
estranho, 10002, representa -810 e no tem correspondente positivo. Os nmeros de
sinal/magnitude abrangem a gama [-7, 7]. O bit mais significativo o bit de sinal. Os nmeros
positivos [1, 7] compartilham a mesma codificao dos nmeros sem sinal. Os nmeros negativos
so simtricos, mas tm o bit de sinal cativo. O zero possui a dupla representao de 0000 e 1000.
Assim, os nmeros de N-bit de sinal/magnitude representam apenas 2N - 1 inteiros por causa das
duas representaes para 0.
22
1.5. PORTAS LGICAS

Agora que sabemos como usar variveis binrias para representar informaes, vamos explorar os
sistemas digitais que executam operaes sobre essas variveis binrias. As portas lgicas so circuitos
digitais simples que possuem uma ou mais entradas digitais e produzem uma sada binria. As portas
lgicas so desenhadas com um smbolo que mostra a entrada (ou entradas) e a sada. As entradas so
normalmente desenhadas do lado esquerda (ou superior) e as sadas do lado direito (ou inferior). Os
projetistas digitais normalmente usam letras perto do incio do alfabeto para as entradas da porta e a
letra Y para a sada da porta. A relao entre as entradas e a sada pode ser descrita por uma tabela
verdade ou uma equao booleana. A tabela verdade lista as entradas esquerda e a sada
correspondente direita. As tabelas possuem uma linha para cada combinao possvel de entradas.
Uma equao booleana uma expresso matemtica que usa variveis binrias.
1.5.1. Porta NOT
Uma porta NOT tem uma entrada, A, e uma sada, Y, como mostrado na Figura 1.12. A sada da porta
NOR o inverso da sua entrada. Se A FALSE, ento Y TRUE. Se A TRUE, ento Y FALSE. Esta relao
resumida pela tabela verdade e a equao booleana na figura. A linha sobre A na equao booleana
designada de NOT, ento Y = lido "Y igual a NO A." A porta NOT tambm chamado de inversora.
Outros textos utilizam uma variedade de notaes para NOT, incluindo Y = A', Y = A, Y = !A ou Y =
~A. Usaremos Y = exclusivamente, mas no se confunda se encontrar outra notao em outros
lugares.
1.5.2. Buffer
A outra porta lgica de uma entrada chamada de buffer e mostrada na Figura 1.13 Ela Figura 1.12 Porta NOT
simplesmente copia a entrada para a sada. Do ponto de vista lgico, um buffer no diferente de um
fio, por isso pode parecer intil. No entanto, do ponto de vista analgico, o buffer pode ter
caractersticas desejveis tais como a capacidade de produzir grandes quantidades de corrente para um
motor ou a capacidade de enviar rapidamente a sua sada para muitas portas. Este um exemplo de
que preciso considerar vrios nveis de abstrao para entender completamente um sistema; a
23
abstrao digital esconde o verdadeiro propsito de um buffer. O smbolo tringulo indica um tampo.
Um crculo na sada indica inverso, como foi visto no smbolo NOT da Figura 1.12.
1.5.3. Porta AND
As portas lgicas de duas entradas so mais interessantes. A porta AND mostrada na Figura 1.14
produz uma sada de TRUE, Y, se e somente se ambos A e B so TRUE. Caso contrrio, a sada FALSE.
Por conveno, as entradas so listadas na ordem 00, 01, 10, 11, como se estivesse contando em
binrio. A equao booleana para uma porta AND pode ser escrita de vrias maneiras: Y = A B, Y =
Figura 1.13 Porta Buffer AB, ou Y = A B. O smbolo pronunciado "interseco" e preferido pelos lgicos. Ns preferimos
Y = AB, leia "Y igual a A e B", porque somos preguiosos.
1.5.4. Porta OR
A porta OR mostrada na Figura 1.15 produz uma sada de TRUE, Y, se A ou B (ou ambas) so TRUE.
A equao Booleana para uma porta OR escrita como Y = A + B ou Y = A B. O smbolo designado
por unio e preferido pelos lgicos. Os projetistas digitais normalmente usam a notao +, Y = A + B
pronunciado "Y igual a A ou B."
1.5.5. Outras Portas de Duas Entradas
A Figura 1.17 apresenta outras portas lgicas comuns de duas entradas. XOR (OU exclusivo,
pronuncia-se "ex-OR") TRUE se A ou B, mas no ambos, so TRUE. Qualquer porta pode ser seguida
por um crculo para inverter o seu funcionamento. A porta NAND implementa NOT AND. A sua sada
Figura 1.14 Porta AND TRUE, a menos que ambas as entradas sejam TRUE. A porta NOR implementa NOT OR. A sua sada
TRUE se nem A nem B so TRUE. Uma porta XOR de N-entradas , s vezes, chamada de porta de
paridade e produz uma sada TRUE se um nmero mpar de entradas so TRUE. Tal como acontece
De acordo com Larry Wall, inventor da com portas de duas entradas, as combinaes de entrada na tabela verdade so listadas em ordem
linguagem de programao Perl, "as trs da contagem.
principais virtudes de um programador
so preguia, impacincia e arrogncia."
24
Figura 1.16 Mais portas de duas entradas

Figura 1.15 Porta OR
Exemplo 1.15 PORTA XNOR
Uma estranha maneira de lembrar o
A Figura 1.17 apresenta o smbolo e a equao Booleana para uma porta XNOR de duas entradas smbolo OR que o seu lado de entrada
que executa o inverso de uma XOR. Complete a tabela verdade. curvo como a boca de Pac Man, de modo
que a porta est com fome e com vontade
Soluo: A Figura 1.18 mostra a tabela verdade. A sada XNOR TRUE se ambas as entradas so FALSE de comer qualquer entrada TRUE que
ou ambas as entradas forem TRUE. A porta XNOR de duas entradas s vezes chamada de porta possa encontrar!
igualdade, porque a sua sada verdadeira quando as entradas so iguais.
Figura 1.17 Porta XNOR
25
Figura 1.18 Tabela verdade XNOR
1.5.6. Portas de Mltiplas Entradas

Existem muitas funes booleanas de trs ou mais entradas. As mais comuns so AND, OR, XOR,
NAND, NOR e XNOR. Uma porta AND de N-entradas produz uma sada TRUE quando todas as suas N-
entradas so TRUE. Uma porta OR de N-entradas produz uma sada TRUE quando pelo menos uma
entrada for TRUE.
Figura 1.19 Porta NOR de 3 entradas Exemplo 1.16 PORTA NOR DE TRS ENTRADAS
A Figura 1.19 mostra o smbolo e a equao booleana para uma porta NOR de trs entradas.
Complete a tabela verdade.
Soluo: A Figura 1.20 mostra a tabela verdade. A sada TRUE somente se nenhuma das entradas for
TRUE.
Exemplo 1.17 PORTA AND DE QUATRO ENTRADAS

A Figura 1.21 mostra o smbolo e a equao booleana para uma porta de quatro-entrada. Crie uma
Figura 1.20 Tabela verdade da porta
NOR de 3 entradas tabela verdade
Soluo: A Figura 1.22 mostra a tabela verdade. A sada TRUE somente se todas as entradas forem
TRUE.
26
1.6. POR BAIXO DA ABSTRAO DIGITAL

Um sistema digital utiliza variveis discretas. No entanto, as variveis so representadas por
quantidades fsicas contnuas tais como a tenso de um fio, a posio de uma roda dentada, ou o nvel
de fluido dentro de um cilindro. Assim, o projetista deve escolher uma maneira de relacionar o valor
contnuo com o valor discreto. Figura 1.21 Porta AND de 4 entradas
Por exemplo, considere que representa um sinal binrio A com uma tenso num fio. Seja 0 volts (V)
indicados por A = 0 e 5 V indicados A = 1. Qualquer sistema real deve tolerar algum rudo, de modo que
4,97 V, provavelmente, deve ser interpretado como A = 1 tambm. Mas e 4,3V? Ou 2,8V? Ou 2.500000V?
1.6.1. Fonte de Tenso
Suponhamos que a menor tenso no sistema de 0 V, tambm chamado terra ou GND. A tenso mais
alta do sistema vem da fonte de alimentao e normalmente chamado de VDD. Na tecnologia de 1970
e 1980, VDD era geralmente 5 V. Com os circuitos integrados a progrediram para transstores menores, a
VDD caiu para 3.3 V, 2.5 V, 1.8 V, 1.5 V, 1.2 V, ou ainda valores menores para economizar energia e evitar
a sobrecarga dos transstores.
1.6.2. Nveis Lgicos
O mapeamento de uma varivel contnua para uma varivel binria discreta feito definindo nveis
lgicos, como mostrado na Figura 1.23. A primeira porta chamada de driver a segunda porta chamada Figura 1.22 Tabela verdade da porta
de receiver. A sada do controlador ligada entrada do receiver. O driver produz um nvel LOW (0) de AND de 4 entradas
sada na gama de 0 a VOL ou um HIGH (1) de sada na gama de VOH a VDD. Se o receiver recebe uma entrada
na faixa de 0 a VIL, ir considerar a entrada a LOW. Se o receiver recebe uma entrada na faixa de VIH a
VDD, ele vai considerar a entrada a HIGH. Se, por algum motivo, como o rudo ou componentes
defeituosas, a entrada do receiver cair na zona proibida entre VIL e VIH, o comportamento da porta
imprevisvel. VOH, VOL, VIH e VIL so chamados de nveis lgicos altos e baixos de sada e entrada.
27
1.6.3.Margens de Rudo
VDD representa a tenso no dreno do
Se a sada do driver para ser interpretada corretamente na entrada do receiver, devemos
transstor semicondutor de xido de
metal usada para construir a maioria dos escolher VOL < VIL e VOH > VIH. Assim, mesmo que a sada do driver seja perturbada por algum rudo,
chips modernos. A tenso de alimentao a entrada do receiver detectar o nvel lgico correto. A margem de rudo a quantidade de rudo
tambm por vezes chamada VCC, que que pode ser adicionado de tal forma que o sinal pode ainda ser interpretado como uma entrada
est para a tenso no coletor de um vlida num pior caso da sada. Como pode ser visto na Figura 1.23, as margens de rudo de baixo e
transstor bipolar de juno utilizado para alto nvel so, respectivamente
construir chips numa tecnologia mais
antiga. O GND por vezes chamado de = (1.2)
VSS, porque a tenso da source de um = (1.3)
transstor semicondutor de xido de
metal. Veja a Seo 1.7 para mais
informaes sobre transstores.
Figura 1.23 Nveis lgicos e margens de rudo
28
Exemplo 1.18 DETERMINAR AS MARGENS DE RUDO

Considere o circuito inversor da Figura 1.24. VO1 a tenso de sada do inversor I1, e VI2 a tenso
de entrada do conversor I2. Ambos os conversores tm as seguintes caractersticas: VDD = 5 V, VIL = 1,35
V, VIH = 3.15 V, VOL = 0,33 V e VOH = 3,84 V. Quais so as margens de rudo de nvel baixo e alto do
inversor? o circuito pode tolerar 1 V de rudo entre VO1 e VI2?
Figura 1.24 Circuito inversor
Soluo: As margens de rudo do inversor so: NML = VIL - VOL = (1,35 V - 0,33 V) = 1,02 V, NMH = VOH -
VIH = (3,84 V - 3,15 V) = 0,69 V. O circuito pode tolerar 1 V de rudo quando a sada est a LOW (NML =
1,02 V), mas no quando a sada est a HIGH (NMH = 0,69 V). Por exemplo, suponha que o driver, I1,
gera no pior caso o valor HIGH, VO1 = VOH = 3,84 V. Se o rudo fizer com que a tenso diminua 1 V antes
de atingir a entrada do receptor, VI2 = (3,84 V - 1 V) = 2,84 V. Este menor do que o valor de entrada DC indica um comportamento em que
HIGH aceitvel, VIH = 3,15 V, de modo que o receiver pode no detectar uma entrada HIGH adequada. uma tenso de entrada mantida
constante ou as alteraes ocorrem
1.6.4. Caracterstica de Transferncia DC devagar o suficiente para que o resto do
Para entender os limites da abstrao digital, devemos aprofundar o comportamento analgico de sistema possa manter-se. A raiz histrica
uma porta lgica. A caracterstica de transferncia DC de uma porta lgica descreve a tenso de sada do termo vem da corrente contnua, um
como uma funo da tenso de entrada quando a entrada alterada de forma suficientemente lenta mtodo de transmisso de energia
para que a sada possa manter-se. chamada de caractersticas de transferncia porque descreve a atravs de uma linha com uma tenso
constante. Em contraste, a resposta
relao entre as tenses de entrada e sada.
transiente de um circuito o
Um inversor ideal dever ter um limiar de comutao brusco a VDD/2, conforme comportamento quando uma tenso de
mostrado na Figura 1.25 (a). Para V(A) < VDD/2, V(Y) = VDD. Para V(A) > VDD/2, entrada varia rapidamente. A Seo 2.9
V (Y) = 0. Neste caso, VIH = VIL = VDD/2. VOH = VDD e VOL = 0. explora mais a resposta transitria.
29
Um inversor verdadeiro muda gradualmente mais entre os extremos, tal como mostrado na Figura
1.25 (b). Quando a tenso de entrada V(A) 0, a tenso de sada V(Y) = VDD. Quando V(A) = VDD, V (Y)
= 0. No entanto, a transio entre estes extremos suave e no pode ser exatamente centrada em
VDD/2. Isso levanta a questo de como definir os nveis lgicos.
Um lugar razovel para escolher os nveis lgicos onde o declive da caracterstica de
transferncia d(Y)/dV(A) -1. Estes dois pontos so chamados de pontos de ganho unitrio.
Escolhendo os nveis lgicos nos pontos de ganho unitrio geralmente maximiza as margens de rudo.
Se VIL foi reduzido, VOH s iria aumentar por uma pequena quantidade. Mas se VIL for aumentado, VOH
cairia vertiginosamente.
Figura 1.25 Caracterstica de transferncia DC e nveis lgicos
30
1.6.5. A Disciplina Esttica

Para evitar entradas que caem na zona proibida, as portas lgicas digitais so concebidas de
acordo com a disciplina esttica. A disciplina esttica requer que, dadas as entradas logicamente
vlidas, cada elemento do circuito ir produzir sadas logicamente vlidas.
Conformando-se com a disciplina esttica, os projetistas digitais sacrificaram a liberdade de usar
elementos de circuito analgico arbitrrios para obterem a simplicidade e a robustez dos circuitos
digitais. Eles permitem elevar o nvel de abstrao de analgico para digital, aumentando a
produtividade de projeto ao esconder detalhes desnecessrios.
A escolha de VDD e dos nveis lgicos arbitrria, mas todas as portas que se comunicam devem
ter nveis lgicos compatveis. Por conseguinte, as portas so agrupadas em famlias lgicas de modo
a que todas as portas de uma famlia lgica obedeam disciplina esttica quando usadas com outras
portas na famlia. As portas lgicas da mesma famlia lgica encaixam como Legos, as quais usam
tenses de alimentao e nveis lgicos consistentes.
As quatro grandes famlias lgicas que predominaram desde a dcada de 1970 atravs da dcada
de 1990 so a Transistor-Transistor Logic (TTL), a Complementary Metal-Oxide-Semiconductor Logic,
Low Voltage Logic TTL (LVTTL) e Low Voltage Logic CMOS (LVCMOS). Os nveis lgicos utilizados so
comparados na Tabela 1.4. Desde ento, as famlias lgicas tm-se dividido com a proliferao das
tenses de alimentao ainda mais baixas. O Apndice A.6 revisita as famlias lgicas mais populares
em detalhe.
31
Tabela 1.4 Famlias lgicas de nveis lgicos de 5 V e 3.3 V
Tabela 1.5 Compatibilidade das famlias lgicas
Exemplo 1.19 COMPATIBILIDADE DAS FAMLIAS LGICAS

Quais das famlias lgicas apresentadas na Tabela 1.4 podem comunicar entre elas de forma
confivel?
Soluo: A Tabela 1.5 lista a compatibilidade lgica entre famlias lgicas. Note-se que uma famlia
com lgica de 5 V, tais como a TTL ou a CMOS pode produzir uma tenso de sada to alto quanto 5V.
Se este sinal de 5 V aciona a entrada de uma famlia de 3,3 V, tal como a lgica LVTTL vs LVCMOS,
pode danificar o receiver, a menos que este seja especialmente concebido para ser "5 volts
compatvel."
32
1.7. TRANSSTORES CMOS*

Esta e outras sees marcadas com * so opcionais e no so necessrias para compreender o
fluxo principal do livro.
A Mquina Analtica de Babbage foi construda a partir de engrenagens, e os computadores
elctricos iniciais utilizavam rels ou tubos de vcuo. Os computadores modernos usam transstores
porque so baratos, pequenos, e de confiana. Os transstores so interruptores controlados
eletricamente que ligam ou desligam quando uma tenso ou corrente aplicada a um terminal de
controlo. Os dois principais tipos de transstores so os transstores de juno bipolar (bipolar junction
transistors) e os transstores de efeito de campo de metal-oxido-semicondutor (metal-oxide-
semiconductor field effect transistors) (MOSFET ou transstores MOS).
Em 1958, Jack Kilby na Texas Instruments construiu o primeiro circuito integrado contendo dois
transstores. Em 1959, Robert Noyce na Semiconductor Fairchild patenteou um mtodo de
interconexo de vrios transstores em um nico chip de silcio. Na poca, os transstores custavam
cerca de US $ 10 cada. Robert Noyce, 1927-1990. Nascido em
Burlington, Iowa. Recebeu um B. A. em
Graas a mais de trs dcadas de avanos de fabricao sem precedentes, os engenheiros podem fsica pela Grinnell College eum Ph.D. em
agora empacotar cerca de um bilho de transstores MOSFET num chip de 1 cm2 de silcio, e esses Fsica pelo MIT. Apelidado de "prefeito do
transstores custam menos do que 10 micro centavos cada. A capacidade e os custos continuam a Vale do Silcio" por sua profunda
melhorar por uma ordem de magnitude a cada 8 anos ou mais. Os MOSFET so agora os blocos de influncia sobre a indstria.
construo de quase todos sistemas digitais utilizam. Nesta seo, vamos espreitar por baixo da Co-Fundador da Fairchild Semiconductor
abstrao digital para ver como as portas lgicas so construdas a partir de MOSFET. em 1957 e da Intel em 1968. Inventou o
circuito integrado. Muitos engenheiros de
1.7.1. Semicondutores
suas equipes fundaram outras empresas
Os transstores MOS so construdos a partir de silcio, o tomo predominante na pedra e areia. O
de semicondutores.
silcio (Si) um tomo do grupo IV, por isso, tem quatro eltrons na sua camada de valncia e forma
ligaes com quatro tomos adjacentes, resultando numa rede cristalina. A Figura 1.26 (a) mostra a ( 2006, Intel Corporation. Reproduzido
estrutura em duas dimenses para facilidade de desenho, mas devemos lembrar que a rede com permisso).
efetivamente forma um cristal cbico. Na figura, uma linha representa uma ligao covalente. Por si
33
s, o silcio um mau condutor porque todos os eltrons esto amarrados em ligaes covalentes.
No entanto, torna-se um condutor melhor quando pequenas quantidades de impurezas, chamadas
tomos dopantes, so cuidadosamente adicionadas. Se um dopante do grupo V, como arsnio (As)
adicionado, os tomos dopantes tm um eltron extra que no est envolvido nas ligaes. Os
eltrons podem facilmente mover-se sobre a estrutura, deixando um tomo dopante ionizado (As+)
para trs, como mostrado na Figura 1.26 (b). O eltron carrega uma carga negativa, de modo que
chamamos o arsnio de dopante do tipo-n. Por outro lado, se um dopante do grupo III, tais como o
boro (B), adicionado, aos tomos dopantes falta um eltron, como mostrado na Figura 1.26 (c).
Esta falta de eltrons denominada de lacuna. Um eltron de um tomo de silcio vizinho pode
mover-se para preencher a ligao em falta, formando um tomo dopante ionizado (B-) e deixando
uma lacuna no tomo de silcio vizinho. De um modo semelhante, a lacuna pode migrar em torno da
estrutura. A lacuna uma falta de carga negativa, por isso, atua como uma partcula carregada
positivamente. Por isso, chamamos o Boro de dopante do tipo-p. Uma vez que a condutividade de
silcio muda ao longo de muitas ordens de grandeza, dependendo da concentrao dos dopantes, o
silcio designado de semicondutor.
1.7.2. Dodos
A juno entre o silcio do tipo-p e do tipo-n, silcio chamado de dodo. A regio do tipo-p
chamada de nodo e a regio de tipo-n chamada de ctodo, conforme ilustrado na Figura 1.27.
Quando a tenso no nodo sobe acima da tenso no ctodo, o dodo polarizado diretamente e a
corrente flui atravs do dodo a partir do nodo para o ctodo. Mas, quando a tenso de nodo
menor do que a tenso no ctodo, o dodo polarizado reversa, e a corrente no passa. O smbolo
de dodo mostra intuitivamente que a corrente flui em uma nica direo.
Figura 1.26 Estrutura cristalina do

Silcio de tomos dopantes
34
1.7.3. Capacitor
Um capacitor constitudo por dois condutores separados por um isolador. Quando uma tenso V
aplicada a um dos condutores, o condutor acumula a carga eltrica Q e o outro condutor acumula a
carga -Q oposta. A capacitncia C do capacitor a razo entre a carga e a tenso:
C = Q / V. A capacitncia proporcional ao tamanho dos condutores e inversamente proporcional Figura 1.27 Dodo de Juno p-n.
distncia entre eles. O smbolo para um capacitor est ilustrado na Figura 1.28. Estrutura e smbolo
A capacidade importante porque o carregamento ou descarga de um condutor leva tempo e

energia. Uma capacidade maior significa que um circuito ser mais lento e necessita de mais energia
para funcionar. A velocidade e a energia sero discutidas ao longo deste livro.
1.7.4. Transstores nMOS e pMOS
Figura 1.28 Smbolo do capacitor
Um MOSFET um sanduche de vrias camadas de conduo e materiais isolantes. Os MOSFET so
construdos a partir de finas wafers de silcio com cerca de 15 a 30 cm de dimetro. O processo de
fabrico comea com uma simples wafer. O processo envolve uma sequncia de passos ao longo dos
quais os dopantes so implantados ao silcio, filmes finos de dixido de silcio e silcio so produzidos,
e o metal depositado. Entre cada passo, a wafer padronizada de modo a que os materiais aparecem
apenas onde so desejados. Uma vez que os transstores tm comprimento de uma fraco de mcron
(1 m= 1 micron = 106 m.) toda a bolacha processada de uma s vez, por isso pouco dispendioso o
fabrico de bilhes de transstores de cada vez. Uma vez que o processamento esteja concludo, a wafer
cortada em retngulos chamados de chips ou dice que contm milhares, milhes ou at bilhes de
transstores. O chip testado e, em seguida, colocado num plstico ou pacote de cermico com pinos Tcnicos numa sala limpa da Intel usando
de metal para conect-lo a uma placa de circuito. fato de proteo Gore-Tex para evitar que
partculas dos seus cabelos, pele e roupas
A sanduche de MOSFET consiste numa camada condutora chama de porta no topo de uma camada
contaminassem os transstores
isolante de dixido de silcio (SiO2) na parte superior da bolacha de silcio, o chamado substrato.
microscpicos em wafers de silcio
Historicamente, a porta foi construda a partir de metal, da o nome de semicondutores de xidos de ( 2006, Intel Corporation. Reproduzido
metal. Os processos de fabrico modernos usam silcio policristalino para a porta, porque no funde com permisso).
durante os passos de processamento de alta temperatura subsequentes. O dixido de silcio mais
conhecido como vidro e muitas vezes chamado simplesmente de xido na indstria de
35
semicondutores. A sanduche de metal-xido-semicondutor forma um condensador, em que uma

camada fina de xido isolante chamado de dieltrico separa as placas de metal e semicondutoras.
Um pacote dual-in-line de 40 pinos (DIP)

contm um pequeno chip (pouco visvel)
no centro que est ligado a 40 pinos de
metal, 20 por lado, por fios de ouro mais
finos do que um fio de cabelo (fotografia
de Kevin Mapp. Harvey Mudd College).
Figura 1.29 Transstores nMOS e pMOS
Existem dois tipos de MOSFET: nMOS e pMOS. A Figura 1.29 mostra seces transversais de
cada tipo, feito por corte de uma wafer e olhando para ele de lado. Os transstores do tipo-n,
chamado nMOS, tm regies dopantes do tipo-n adjacentes porta chamada de source e dreno
e so construdas sobre um substrato semicondutor do tipo-p. Os pMOS so exatamente o
oposto, que consiste numa source de tipo-p e a regio do dreno num substrato tipo-n.
Um MOSFET comporta-se como um interruptor controlado por tenso em que a tenso da
porta cria um campo elctrico que liga ou desliga a ligao entre a source e o dreno. A designao
de transstor de efeito de campo vem deste princpio de operao. Vamos comear por explorar
o funcionamento de um transstor nMOS.
36
O substrato de um transstor nMOS est normalmente ligada a GND, a tenso mais baixa no sistema. Os terminais da source e do dreno so
Em primeiro lugar, consideremos a situao quando a porta est tambm a 0 V, conforme mostrado fisicamente simtricos. No entanto,
na Figura 1.30 (a). Os dodos entre a source ou o dreno e o substrato esto polarizados inversamente podemos dizer que a carga flui da source
porque a tenso da source ou do dreno no negativa. Assim, no existe um caminho para o fluxo de para o dreno. Num transstor nMOS, a
corrente entre a source e o dreno, de modo que o transstor est ao corte. Agora, considere que a porta carga transportada por eltrons, que
colocada a VDD, como mostrado na Figura 1.30 (b). Quando uma tenso positiva aplicada placa de fluem de tenso negativa para a tenso
topo de um condensador, estabelece um campo elctrico que atrai a carga positiva para a placa de positiva. Num transstor pMOS, a carga
transportada por lacunas, que fluem da
topo e a carga negativa para a placa inferior. Se a tenso suficientemente grande, de modo que muita
tenso positiva para a tenso negativa. Se
carga negativa atrada para o lado de baixo da porta a regio inverte do tipo-p para se tornar
desenharmos esquemas com a tenso
efetivamente do tipo-n. Esta regio invertida denominada de canal. Agora, o transstor tem um mais positiva na parte superior e a mais
percurso contnuo a partir da source do tipo-n, atravs do canal do tipo-n, para o dreno do tipo-n, de negativo na parte inferior, a source de
modo que os eltrons podem fluir da source para o dreno. O transstor est em conduo. A tenso da cargas (negativa) num transstor nMOS
porta necessria para ligar um transstor chamada de tenso de limiar, Vt, e tipicamente de 0,3 a o terminal inferior e a fonte de cargas
0,7 V. (positivas) num transistor pMOS o
terminal superior.
Um tcnico segura uma bolacha de 12

Figura 1.30 Funcionamento de um transstor nMOS polegadas que contm centenas de
microprocessadores
( 2006, Intel Corporation. Reproduzido
com permisso).
37
Os transstores pMOS trabalham exatamente de maneira oposta, como pode ser deduzido a partir
do crculo no seu smbolo mostrado na Figura 1.32. O substrato mantido a VDD. Quando a porta est
tambm a VDD, e o transstor pMOS fica ao corte. Quando a porta est a GND, o canal inverte para tipo-
p e o transstor pMOS fica em conduo.
Infelizmente, os MOSFET no so interruptores perfeitos. Em particular, os transstores nMOS
comutam bem para 0, mas mal para 1. Especificamente, quando a porta de um transstor nMOS est
a VDD, o dreno s ir comutar entre 0 e VDD - Vt. Da mesma forma, os pMOS comutam bem para 1, mas
mal para 0. No entanto, vamos ver que possvel construir portas lgicas que usam transstores apenas
no seu modo bom.
Figura 1.31 Modelo de interrupto dos MOSFET
Os transstores nMOS precisam de um substrato do tipo-p, e os pMOS precisam de um substrato

tipo-n. Para construir os dois tipos de transstores no mesmo chip, os processos de fabricao
normalmente comeam com uma wafer do tipo-p, em seguida, implantam regies do tipo-n chamadas
de wells onde os transstores pMOS sero construdos. Estes processos que fornecem ambos os tipos
de transstores so chamados Complementar MOS ou CMOS. Os processos CMOS so utilizados para
construir a grande maioria de todos os transstores fabricados hoje.
Em resumo, os processos CMOS do-nos dois tipos de comutadores controlados eletricamente,
Figura 1.32 Esquemtico de uma
porta NOT como mostrado na Figura 1.32. A tenso na porta (g) regula o fluxo de corrente entre a source (s) e o
dreno (d). Os transstores nMOS esto ao corte quando a porta est 0 e em conduo quando a porta
38
est a 1. Os transstores pMOS so exatamente o oposto: em conduo quando a porta est a 0 e ao corte
quando a porta est a 1.
1.7.5. Porta CMOS NOT
A Figura 1.32 apresenta um diagrama esquemtico de uma porta NOT construda com transstores
CMOS. O tringulo indica GND, e a barra indica VDD; esses rtulos estaro omissos em esquemas
futuros. O transstor nMOS, N1, est ligado entre GND e a sada Y. O transstor pMOS, P1, est ligado
entre VDD e a sada Y. Ambas as portas dos transstores so controladas atravs da entrada, A.
Se A = 0, N1 est OFF e P1 est ON. Assim, Y est ligado a VDD, mas no a GND, e puxado para cima
um 1 lgico. P1 permite um bom 1. Se A = 1, N1 est ON e P1 est OFF, e Y puxado para baixo um 0
lgico. N1 permite um bom 0. Verificando a tabela verdade na Figura 1.12, vemos que o circuito de
Gordon Moore, 1929-. Nascido em San
facto uma porta NOT. Francisco. Recebeu um B. S. em qumica
1.7.6. Outras Portas Lgicas CMOS pela Universidade de Berkeley e um Ph.D.
em qumica e fsica da Caltech. Co-
A Figura 1.33 apresenta um diagrama esquemtico de uma porta NAND de duas entradas. Nos
Fundador da Intel em 1968 com Robert
diagramas esquemticos, as ligaes so sempre unidas utilizando junes de trs vias. Nos
Noyce. Observa em 1965 que o nmero
cruzamentos so utilizadas junes de quatro vias e somente um ponto mostrado. Os transstores de transstores num chip de computador
nMOS N1 e N2 esto ligados em srie; ambos os transstores nMOS devem estar em conduo de duplica a cada ano. Esta tendncia tornou-
modo a puxar a sada para baixo para GND. Os pMOS P1 e P2 esto em paralelo; apenas um transstor se conhecida como Lei de Moore. Desde
pMOS deve estar em conduo para puxar a sada para VDD. A Tabela 1.6 lista o funcionamento das 1975, nmero de transstores dobra a
redes de pull-up e de pull-down e o estado da sada, demonstrando que a porta funciona como um cada dois anos. Um corolrio da Lei de
NAND. Por exemplo, quando A = 1 e B = 0, N1 est ON, mas N2 est OFF, bloqueando o caminho de Y Moore que o desempenho do
para GND. P1 est OFF, mas P2 est ON, criando um caminho de VDD para Y. Assim, Y puxado para microprocessador dobra a cada 18 a 24
cima a 1. meses. As vendas de semicondutores
tambm tm aumentado
exponencialmente. Infelizmente, o
consumo de energia tem tambm
aumentado exponencialmente.
( 2006, Intel Corporation. Reproduzido

com permisso).
Figura 1.33 Esquemtico de uma porta NAND de duas entradas
39
Tabela 1.6 Operao de uma porta AND
Figura 1.34 Forma geral de uma

porta logica inversora
A Figura 1.34 mostra a forma geral utilizada para construir qualquer porta lgica de inverso, como
NOT, NAND ou NOR. Os transstores nMOS permitem bons 0, por isso uma rede pull-down de
transstores nMOS colocada entre a sada e GND para puxar a baixo a sada para 0. Os transstores
pMOS permitem bons 1, ento uma rede de pull-up de transstores pMOS colocada entre a sada e
VDD para puxar a sada at 1. As redes podem ser constitudas por transstores em srie ou em paralelo.
Quando os transstores esto em paralelo, a rede est ON se qualquer transstor est em conduo.
Quando os transstores esto em srie, a rede est ON somente se ambos os transstores esto em
conduo. A barra atravs da ligao de entrada indica que a porta pode receber mltiplas entradas.
Se tanto a rede de pull-up como de pull-down estiverem ON simultaneamente, um curto-circuito
existiria entre o VDD e o GND. A sada da porta pode estar numa zona proibida e os transstores
consumirem grandes quantidades de energia, possivelmente o suficiente para queimar. Por outro
lado, se tanto a rede de pull-up como de pull-down estiverem OFF simultaneamente, a sada no
40
Projetistas experientes afirmam que estaria ligada nem a VDD nem a GND. Dizemos que a sada flutua. O seu valor indefinido. As sadas
dispositivos eletrnicos funcionam flutuantes so geralmente indesejveis, mas na Seo 2.6, veremos como elas podem,
porque contm fumaa mgica. Eles eventualmente, ser usadas em vantagem do projetista.
confirmam esta teoria com a observao
de que, se a fumaa mgica deixa o Numa porta lgica a funcionar adequadamente, uma das redes deve estar ON e a outra OFF, em
dispositivo ele deixa de trabalhar. determinado momento, de modo que a sada esteja puxado para HIGH ou para LOW e no em curto-
circuito ou flutuante. Podemos garantir isso usando a regra de complementos de conduo. Quando
os transstores nMOS esto em srie, os transstores pMOS devem estar em paralelo. Quando os
transstores nMOS esto em paralelo, os transstores PMOS devem estar em srie.
Exemplo 1.20 ESQUEMTICO DE UM NAND DE TRS ENTRADAS

Desenhe um esquema para uma porta NAND de trs entradas usando transstores CMOS.
Soluo: A porta NAND deve produzir uma sada a 0 somente quando todas as trs entradas
estiverem a 1. Assim, a rede de pull-down deve ter trs transstores nMOS em srie. Atravs da regra
de complemento da conduo, os pMOS deve estar em paralelo. Uma porta destas mostrada na
Figura 1.35; pode-se verificar a funo, observando que a tabela verdade est correta.
Exemplo 1.21 ESQUEMTICO DE UM NOR DE DUAS ENTRADAS

Desenhe um esquema para uma porta NOR de duas entradas usando transstores CMOS.
Soluo: A porta NOR deve produzir uma sada a 0 se qualquer entrada estiver a 1. Assim, a rede de
pull-down deve ter dois transstores nMOS em paralelo. Pela regra de complemento de conduo, os
pMOS devem estar em srie. Uma porta mostrada na Figura 1.36.
Figura 1.35 Esquemtico de uma
porta NAND de trs entradas
Exemplo 1.22 ESQUEMTICO DE UM AND DE DUAS ENTRADAS
Desenhe um esquema para uma porta AND de duas entradas usando transstores CMOS.
41
Soluo: impossvel construir uma porta AND com uma nica porta CMOS. No entanto, a
construo de portas NAND e NOT fcil. Assim, a melhor maneira de construir uma porta AND
utilizando transstores CMOS a utilizao de um NAND seguido por um NOT, como mostrado na
Figura 1.37.
1.7.7. Portas de Transmisso

Por vezes, os projetistas acham conveniente utilizar um interruptor ideal que possam transmitir Figura 1.36 Esquemtico de uma
bem tanto o 0 como o 1. Lembre-se que os transstores nMOS so bons a transmitir o 0 e os pMOS porta NOR de duas entradas
so bons a transmitir o 1, ento a combinao paralela dos dois permite transmitir ambos os valores.
A Figura 1.38 mostra tal circuito, chamado de porta de transmisso ou porta de passagem. Os dois
lados do interruptor so chamados de A e B porque um interruptor bidirecional e no tem nenhum
lado de entrada ou sada preferida. Os sinais de controlo so chamados enable, EN e . Quando EN
= 0 e = 1, ambos os transstores esto desligados. Assim, a porta de transmisso est OFF ou Figura 1.37 Esquemtico de uma
descativada, ento A e B no esto ligados. Quando EN = 1 e = 0, a porta de transmisso est porta AND de duas entradas
ligada ou cativada, e qualquer valor lgico pode fluir entre A e B.
1.7.8. Lgica Pseudo-nMOS
Uma porta NOR CMOS de N-entradas usa N nMOS em paralelo e N transstores pMOS em srie.
Os transstores em srie so mais lentos do que os transstores em paralelo, assim como as
resistncias em srie tm maior resistncia do que resistores em paralelo. Alm disso, os pMOS so
mais lentos do que os transstores nMOS porque as lacunas no se podem mover em torno da
estrutura de silcio to rapidamente como os eltrons. Portanto, os transstores nMOS em paralelo Figura 1.38 Porta de transmisso
so rpidos e os transstores pMOS em srie so lentos, especialmente quando muitos esto em
srie.
A lgica pseudo-nMOS substitui a pilha lenta de transstores pMOS com um nico transstor pMOS
fraco que est sempre ON, como mostrado na Figura 1.39. Este transstor pMOS frequentemente
chamado de fraco pull-up. As dimenses fsicas do transstor pMOS so selecionadas de modo que o
transstor PMOS v puxar a sada Y a HIGH fracamente, isto , apenas se nenhum dos transstores
nMOS est em conduo. Mas, se algum transstor nMOS est em conduo, domina os pull-up fracos
e puxa Y para baixo o suficiente perto de GND para produzir um 0 lgico.
42
A vantagem da lgica pseudo-nMOS que ela pode ser usada para construir portas NOR rpidas
com muitas entradas. Por exemplo, a Figura 1.40 mostra um NOR pseudo-nMOS de quatro-entrada.
As portas pseudo-nMOS so teis para certas matrizes de memria e lgica discutidas no Captulo 5.
A desvantagem que existe um curto-circuito entre VDD e GND quando a sada est a LOW; os
transstores fracos pMOS e nMOS esto ambos em conduo. O curto-circuito deixa passar energia
de forma contnua, de modo que a lgica pseudo-nMOS deve ser utilizada com moderao.
As portas pseudo-nMOS obtiveram o seu nome na dcada de 1970, quando os processos de
fabricao s tinham transstores nMOS. Um transstor fraco nMOS foi utilizado para puxar a sada a Figura 1.39 Peudo-nMOS genrico
HIGH porque os transstores PMOS no estavam disponveis.
1.8. CONSUMO DE ENERGIA

O consumo de energia a quantidade de energia utilizada por unidade de tempo. O consumo de
energia de grande importncia em sistemas digitais. A vida til da bateria dos sistemas portteis,
como telefones celulares e computadores portteis limitada pelo consumo de energia. A potncia
Figura 1.40 Porta NOR de quatro
tambm significativa para os sistemas que esto ligados, porque a eletricidade custa dinheiro e
entradas pseudo-nMOS
porque o sistema vai sobreaquecer se consumir muita energia.
Os sistemas digitais consumem energia dinmica e esttica. A energia dinmica utilizada para
carregar condensadores medida que os sinais mudam entre 0 e 1. A energia esttica utilizada
mesmo quando os sinais no mudem e o sistema estiver ocioso.
As portas lgicas e as ligaes que as conectam tm uma capacidade. A energia obtida a partir da
fonte de alimentao para carregar um condensador C tenso VDD CVDD2. Se a tenso no
condensador comuta frequncia f (ou seja, f vezes por segundo), o condensador carrega f/2 e
descarrega f/2 vezes por segundo. A descarga no retira energia da fonte de alimentao, de modo
que o consumo de energia dinmica
1
= 2 2 (1.4)
43
Exemplo 1.23 CONSUMO DE ENERGIA

Um telefone celular tem uma bateria de 6 watt-hora (W-hr) e opera a 1,2 V. Suponha que, quando
ele est em uso, funciona a 300 MHz e a quantidade mdia de capacidade a comutar no chip num
dado tempo de 10 nF (10-8 Farads). Quando em uso, ele tambm transmite 3 W de potncia atravs
da sua antena. Quando o telefone no est em uso, a potncia dinmica cai para quase zero, porque
o processamento de sinal est desligado. Mas o telefone requer tambm a 40 mA de corrente de
repouso se ele est em uso ou no. Determinar a vida til da bateria do telefone (a) se ele no estiver
sendo usado, e (b) se ele est sendo usado continuamente.
Soluo: A potncia esttica Pesttica = (0,040 A) (1,2 V) = 48 mW. (A) Se o telefone no estiver sendo
usado, este o nico consumo de energia, de modo que a vida til da bateria (6 Whr) / (0,048 W) =
125 horas (cerca de 5 dias). (B) Se o telefone estiver sendo usado, a potncia dinmica P dinmica =
(0,5)(10-8 F)(1,2 V)2(3 108 Hz) = 2,16 W. Juntamente com a potncia esttica e de transmisso, a
potncia total ativa 2,16 W + 0,048 W + 3 W = 5,2 W, de modo que a vida til da bateria de 6 W-
hr / 5.2 W = 1.15 horas. Este exemplo simplifica a operao real de um telefone celular, mas ilustra as
ideias-chave de consumo de energia.
Os sistemas elctricos consomem alguma corrente, mesmo quando eles esto ociosos. Quando os
transstores esto ao corte, eles perdem uma pequena quantidade de corrente. Alguns circuitos, tais
como as portas pseudo-nMOS discutidas na Seco 1.7.8, tm um caminho de VDD para GND atravs
do qual a corrente flui continuamente. A corrente esttica total, o IDD, tambm chamada de corrente
de fuga ou a corrente de alimentao de repouso que flui entre VDD e GND. O consumo de energia
esttica proporcional a esta corrente esttica:
= (1.5)
44
1.9. SUMRIO E ANTECIPAO

H 10 tipos de pessoas neste mundo: aqueles que podem contar em binrio e aqueles que no
podem.
Este Captulo introduziu princpios para a compreenso e concepo de sistemas complexos.
Embora o mundo real seja analgico, os projetistas digitais disciplinam-se para utilizar um
subconjunto discreto de possveis sinais. Em particular, variveis binrias tm apenas dois estados:
0 e 1, tambm chamados de FALSE e TRUE ou HIGH e LOW. As portas lgicas calculam uma sada
binria de uma ou mais entradas binrias. Algumas das portas lgicas comuns so:
NOT : TRUE quando a entrada FALSE

AND: TRUE quando todas as entradas so TRUE
OR: TRUE quando todas as entradas so TRUE
XOR : TRUE quando um nmero mpar de entradas TRUE
As portas lgicas so normalmente construdas a partir de transstores CMOS, que se comportam
como interruptores controlados eletricamente. Os transstores nMOS ficam em conduo quando a
gate est a 1. Os transstores pMOS ficam em conduo quando a gate est a 0.
Nos Captulos 2 ao 5 continuamos o estudo da lgica digital. O Captulo 2 aborda a lgica
combinatria, em que as sadas dependem apenas das entradas atuais. As portas lgicas introduzidas
j so exemplos de combinaes lgicas. O leitor vai aprender a projetar circuitos que envolvem
mltiplas portas para implementar uma relao entre as entradas e as sadas especificadas por uma
tabela verdade ou uma equao booleana. O Captulo 3 aborda a lgica sequencial, em que as sadas
dependem tanto do estado atual como passado das entradas. Os registros so elementos sequenciais
comuns que recordam a sua entrada anterior. As mquinas de estados finitos, construdas a partir
de registros e lgica combinatria, so uma maneira poderosa para construir sistemas complicados
de uma maneira sistemtica. Estudamos tambm o sincronismo de sistemas digitais para analisar o
quo rpido este pode operar. O Captulo 4 descreve as linguagens de descrio de hardware (HDL).
As HDL esto relacionadas com as linguagens de programao convencionais, mas so usadas para
45
simular e construir hardware em vez de software. A maioria dos sistemas digitais de hoje projetada
com HDL. SystemVerilog e VHDL so as duas lnguas predominantes, e elas so cobertas em paralelo
neste livro. O Captulo 5 estuda outros blocos combinatrios e sequenciais de construo, tais como
somadores, multiplicadores e memrias.
O Captulo 6 aborda a arquitetura de computadores. Ele descreve o processador MIPS, um
microprocessador padro da indstria usado em electrnica de consumo, algumas estaes de
trabalho Silicon Graphics, e muitos sistemas de comunicaes, tais como televisores, hardware de
rede e ligaes sem fios. A arquitetura MIPS definida por seus registros e conjunto de instrues
assembly. O leitor vai aprender a escrever programas em linguagem assembly para o processador
MIPS de modo que possa comunicar com o processador na sua lngua nativa.
Os Captulos 7 e 8 estabelecem a ponte entre a lgica digital e a arquitetura de computadores. O
Captulo 7 investiga a microarquitetura, a organizao dos blocos de construo digitais, tais como
somadores e registradores, necessrios para construir um processador. Nesse Captulo, o leitor
aprende a construir o seu prprio processador MIPS. Na verdade, aprende trs microarquiteturas que
ilustram diferentes compromissos de desempenho e custo. O desempenho do processador tem
aumentado exponencialmente, exigindo cada vez sistemas de memria mais sofisticadas para
alimentar a procura insacivel por dados. O Captulo 8 investiga a arquitetura do sistema de memria
e tambm descreve como os computadores comunicam com dispositivos perifricos, como teclados
e impressoras.
46
Exerccios
Exerccio 1.1 Explique num pargrafo, pelo menos, trs nveis de abstrao que so utilizados por:
(a) bilogos que estudam o funcionamento das clulas.
(b) qumicos que estudam a composio de matria.
Exerccio 1.2 Explique num pargrafo como as tcnicas de hierarquia, modularidade e regularidade
podem ser utilizadas por
(a) projetistas de automveis.
(b) empresas na gesto das suas operaes.
Exerccio 1.3 Ben Bitdiddle est a construir uma casa. Explique como pode ele usar os princpios de
hierarquia, modularidade e regularidade para economizar tempo e dinheiro durante construo.
Exerccio 1.4 Uma tenso analgica situa-se na gama 0-5 V. Se puder ser medida com uma preciso
de 50 mV, quantos bits de informaes transmite no mximo?
47
Exerccio 1.5 A sala de aula tem um velho relgio na parede cujo ponteiro dos minutos se avariou.
(a) Se o leitor pode ler o ponteiro das horas para o valor mais prximo dos 15 minutos, quantos
bits de informao o relgio transmite sobre o tempo?
(b) Se o leitor sabe se antes ou depois do meio-dia, quantos bits de informao adicional sabe
sobre o tempo?
Exerccio 1.6 Os Babilnios desenvolveram o sistema de numerao sexagesimal (base 60) cerca
de 4000 anos atrs. Quantos bits de informao so transmitidos com um dgito sexagesimal? Como
se escreve o nmero 400010 em sexagesimal?
Exerccio 1.7 Quantos nmeros diferentes podem ser representados com 16 bits?
Exerccio 1.8 Qual o maior nmero binrio de 32 bits sem sinal?
Exerccio 1.9 qual o maior nmero binrio de 16 bits que pode ser representado com
(a) nmeros sem sinal?
(b) nmeros em complemento-2?
(c) nmeros de sinal/magnitude?
Exerccio 1.10 Qual o maior nmero binrio de 32 bits que pode ser representado com
48

(b) nmeros em complemento-2?
Exerccio 1.11 Qual o menor nmero binrio de 16 bits (mais negativo) que pode ser representado
com
(B) nmeros em complemento-2?
Exerccio 1.12 Qual o menor nmero binrio de 32 bits (mais negativo) que pode ser representado
com
(B) nmeros em complemento-2?
Exerccio 1.13 Converta os seguintes nmeros binrios sem sinal para decimal. Apresente o seu
trabalho.
(a) 10102
(b) 1101102
(c) 111100002
49
(d) 0001000101001112
Exerccio 1.14 Converta os seguintes nmeros binrios sem sinal para decimal. Apresente seu
trabalho.
(a) 11102
(b) 1001002
(c) 110101112
(d) 0111010101001002
Exerccio 1.15 Repita o Exerccio 1.13, mas converta em hexadecimal.
Exerccio 1.16 Repita o Exerccio 1.14, mas converta em hexadecimal.
Exerccio 1.17 Converta os seguintes nmeros hexadecimais para decimal. Mostre seu trabalho.
(a) A516
(b) 3B16
(c) FFFF16
(d) D000000016
Exerccio 1.18 Converta os seguintes nmeros hexadecimais para decimal. Mostre seu trabalho.
50
(a) 4E16
(b) 7C16
(c) ED3A16
(d) 403FB00116
Exerccio 1.19 Repita o Exerccio 1.17, mas converta para binrio sem sinal.
Exerccio 1.20 Repita o Exerccio 1.18, mas converta para binrio sem sinal.
Exerccio 1.21 Converta os seguintes nmeros binrios em complemento-2 para decimal.

(a) 10102
(b) 1101102
(c) 011100002
(d) 100111112
Exerccio 1.22 Converta os seguintes nmeros binrios em complemento-2 para decimal.

(a) 11102
(b) 1000112
(c) 010011102
(d) 101101012
51
Exerccio 1.23 Repita o Exerccio 1.21, assumindo que os nmeros binrios esto na forma de
sinal/magnitude, em vez de na representao em complemento-2.
Exerccio 1.24 Repita o Exerccio 1.22, assumindo que os nmeros binrios esto na forma de
sinal/magnitude, em vez de na representao em complemento-2.
Exerccio 1.25 Converta os seguintes nmeros decimais para binrio sem sinal.
(a) 4210
(b) 6310
(c) 22910
(d) 84510
Exerccio 1.26 Converta os seguintes nmeros decimais para binrio sem sinal.
(a) 1410
(b) 5210
(c) 33910
(d) 71110
Exerccio 1.27 Repita o Exerccio 1.25, mas converta para hexadecimal.
52
Exerccio 1.28 Repita o Exerccio 1.26, mas converta para hexadecimal.
Exerccio 1.29 Converta os seguintes nmeros decimais para nmeros de 8-bits em complemento-2
ou indique se o nmero decimal ultrapassa o intervalo.
(a) 4210
(b) -6310
(c) 12410
(d) -12810
(e) 13310
Exerccio 1.30 Converta os seguintes nmeros decimais para nmeros de 8-bits em complemento-2
ou indique se o nmero decimal ultrapassa o intervalo.
(a) 2410
(b) -5910
(c) 12810
(d) -15010
(e) 12710
Exerccio 1.31 Repita o Exerccio 1.29, mas converta para nmeros de sinal/magnitude de 8 bits.
Exerccio 1.32 Repita o Exerccio 1.30, mas converta para nmeros de sinal/magnitude de 8 bits.
53
Exerccio 1.33 Converta os dois nmeros seguintes de 4-bits para 8-bits em complento-2.
(a) 01012
(b) 10102
Exerccio 1.34 Converta os dois nmeros seguintes de 4-bits para 8-bits em complento-2.
(a) 01112
(b) 10012
Exerccio 1.35 Repita o Exerccio 1.33, se os nmeros no possurem sinal em vez de

complemento-2.
Exerccio 1.36 Repita o Exerccio 1.34 se os nmeros no possurem sinal em vez de

complemento-2.
Exerccio 1.37 A base 8 designada como octal. Converta cada um dos nmeros do Exerccio 1.25
para octal.
Exerccio 1.38 A base 8 referida como octal. Converta cada um dos nmeros de Exerccio 1.26
para octal.
54
Exerccio 1.39 Converta cada um dos nmeros seguintes de octal para binrio, hexadecimal e
decimal.
(a) 428
(b) 638
(c) 2558
(d) 30478
Exerccio 1.40 Converta cada um dos seguintes nmeros de octal para binrio, hexadecimal e
decimal.
(a) 238
(b) 458
(c) 3718
(d) 25608
Exerccio 1.41 Quantos nmeros de 5-bit em complemento-2 so maiores do que 0? Quantos so

inferiores a 0? Como que as suas respostas seriam diferentes para nmeros sinal/magnitude?
Exerccio 1.42 Quantos nmeros de 7-bit em complemento-2 so maiores do que 0? Quantos so

inferiores a 0? Como que as suas respostas seriam diferentes para nmeros sinal/magnitude?
55
Exerccio 1.43 Quantos bytes possui uma word de 32-bit? Quantas nibles possui essa word?
Exerccio 1.44 Quantos bytes possui uma word de 64-bits?
Exerccio 1.45 Um dado modem DSL, opera a 768 kbits/s. Quantos bytes pode ele receber num
1 minuto?
Exerccio 1.46 Uma porta USB 3.0 pode enviar dados a 5 Gbits/seg. Quantos bytes pode ela enviar
num 1 minuto?
Exerccio 1.47 Os fabricantes de discos rgidos usam o termo "megabyte" para significar 106 bytes
e "gigabyte" para significar 109 bytes. Quantos GB reais de msica que voc pode armazenar num
disco rgido de 50 GB?
Exerccio 1.48 Estime o valor de 231 sem usar uma calculadora.
Exerccio 1.49 A memria no microprocessador Pentium II organizada como uma matriz

retangular de bits com 28 linhas e 29 colunas. Estimar quantos bits possui sem usar uma calculadora.
Exerccio 1.50 Desenhe uma linha de nmeros anloga da Figura 1.11 para nmeros de 3-bits
sem sinal, em complemento-2, e sinal/magnitude.
56
Exerccio 1.51 Desenhe uma linha de nmeros anloga da Figura 1.11 para nmeros de 2-bits sem
sinal, em complemento-2, e sinal/magnitude.
Exerccio 1.52 Execute as seguintes adies de nmeros binrios sem sinal. Indicar se a soma
transborda ou no num resultado de 4-bits.
(a) 10012 + 01002
(b) 11012 + 10112
Exerccio 1.53 Execute as seguintes adies de nmeros binrios no assinados. Indicar se a soma a
soma transborda ou no num resultado de 8-bits.
(a) 100110012 + 010001002
(b) 110100102 + 101101102
Exerccio 1.54 Repita o Exerccio 1.52, assumindo que os nmeros binrios esto na forma
complemento-2.
Exerccio 1.55 Repita o Exerccio 1.53, assumindo que os nmeros binrios esto na forma
complemento-2.
Exerccio 1.56 Converta os seguintes nmeros decimais para nmeros binrios em complemento-2
de 6-bits e adicione-os. Indique se a soma transborda ou no o resultado de 6-bits.
57
(a) 1610 + 910

(b) 2710 + 3110
(c) -410 + 1910
(d) 310 + -3210
(e) -910 -1610
(f) -2710 + -3110
Exerccio 1.57 Repita o Exerccio 1.56 para os seguintes nmeros.

(a) 710 + 1310
(b) 1710 + 2510
(c) -2610 + 810
(d) 3110 + -1410
(e) -1910 + -2210
(f) -210 + -2910
Exerccio 1.58 Execute as seguintes adies de nmeros hexadecimais sem sinal. Indique se a soma
transborda ou no num resultado de 8-bits (dois dgitos hex).
(a) 716 + 916
(b) 1316 + 2816
(c) AB16 + 3E16
58
(d) AD16 + 8F16
Exerccio 1.59 Execute as seguintes adies de nmeros hexadecimais sem sinal. Indique se a soma
transborda ou no um resultado de 8-bits (dois dgitos hex).
(A) 2216 + 816
(B) 7316 + 2C16
(C) 7F16 + 7 F16
(D) C216 + A416
Exerccio 1.60 Converta os seguintes nmeros decimais em nmeros binrios de 5-bits em

complemento-2 e subtraia-os. Indique se a diferena transborda ou no um resultado de 5-bits.
(a) 910 - 710
(b) 1210 - 1510
(c) -610 1110
(d) 410 - -810
Exerccio 1.61 Converta os seguintes nmeros decimais em nmeros binrios de 6-bits em

complemento-2 e subtraia-os. Indique se a diferena transborda ou no um resultado de 6-bits.
(a) 1810 -1210
(b) 3010 -910
(c) -2.810 -310
59
(d) -1610 - 2110
Exerccio 1.62 Num sistema numrico binrio de N-bits com bias B, os nmeros positivos e
negativos so representados somando o seu valor ao valor de bias B. Por exemplo, para o nmero
de 5-bits com bias de 15, o nmero 0 representado como 01111, 1 como 10000, e assim por
diante. Os sistemas de nmeros com bias so por vezes usados em matemtica de vrgula
flutuante, que ser discutido no Captulo 5. Considere um sistema numrico binrio de 8-bit s
com bias de 12.710
(a) qual o valor decimal que o nmero binrio 100000102 representa?
(b) que nmero binrio representa o valor 0?
(c) qual a representao do valor do nmero mais negativo?
(d) qual a representao do valor do nmero mais positivo?
Exerccio 1.63 Desenhe uma linha numrica anloga da Figura 1.11 para nmeros de 3-bit
com bias de 3 (ver Exerccio 1.62 para uma definio de nmeros com bias).
Exerccio 1.64 Num sistema de codificao binria decimal (BCD), 4 bits so utilizados para
representar um dgito decimal de 0 a 9. Por exemplo, 3710 escrito como 00110111 BCD.
(a) escreva 28910 em BCD
(b) converta 100101010001 BCD para decimal
(c) converta 01101001BCD para binrio
(d) explique porque o BCD pode ser uma maneira til para representar nmeros
60
Exerccio 1.65 responda s seguintes questes relacionadas com os sistemas BCD (ver Exerccio
1.64 para a definio da BCD),
(a) escreva 37110 em BCD
(b) converta 000110000111BCD para decimal
(c) converta 10010101 BCD para binrio
(d) Explique as desvantagens do BCD quando comparado com representaes binrias de
nmeros
Exerccio 1.66 Um disco voador despenhou-se num campo de milho no Nebraska. O FBI
investiga os destroos e encontra um manual de engenharia contendo uma equao no sistema
numrico Marte: 325 + 42 = 411. Se esta equao est correta, quantos dedos o leitor esperaria
que os marcianos tenham?
Exerccio 1.67 Ben Bitdiddle e Alyssa P. Hacker esto tendo uma discusso. Ben diz: "Todos os
inteiros maiores que zero exatamente divisveis por seis tm exatamente dois 1s na sua
representao binria." Alyssa discorda. Ela diz: "No, mas todos esses nmeros tm um nmero
par de 1s na sua representao." Voc concorda com o Ben ou com a Alyssa ou com ambos ou com
nenhum? Explique.
Exerccio 1.68 Ben Bitdiddle e Alyssa P. Hacker esto a ter outra discusso. Ben diz: "Eu posso
obter o complemento-2 de um nmero subtraindo 1 e, em seguida, invertendo todos os bits do
resultado." Alyssa diz: "No, eu posso fazer isso, examinando cada bit do nmero, comeando com
61
o menos significativo. Quando o primeiro 1 encontrado, inverter cada bit subsequente. "Voc
concorda com Ben ou com a Alyssa ou com ambos ou com nenhum? Explique.
Exerccio 1.69 Escreva um programa na sua linguagem favorita (por exemplo, C, Java, Perl) para
converter nmeros de binrio para decimal. O utilizador deve digitar um nmero binrio sem sinal.
O programa deve imprimir o equivalente decimal.
Exerccio 1.70 Repita o Exerccio 1.69, mas que converta de uma base arbitrria b1 para outra base
b2, conforme especificado pelo utilizador. Aceite bases at 16, usando as letras do alfabeto para
dgitos superiores a 9. O utilizador deve introduzir b1, b2, e seguido o nmero a converter na base b1.
O programa deve imprimir o nmero equivalente na base b2.
Exerccio 1.71 Desenhe o smbolo, a equao booleana e tabela verdade para

(a) uma porta OR de trs entradas
(b) uma porta OR exclusivo (XOR) de trs entradas porto
(c) uma porta de quatro entradas XNOR
Exerccio 1.72 Desenhe o smbolo, a equao booleana e tabela verdade para

(a) uma porta OR de quatro entradas
(b) uma porta XNOR de trs entradas
(c) uma porta NAND de cinco entradas
62
Exerccio 1.73 Uma porta de maioria produz uma sada TRUE se e somente se mais de metade
de suas entradas so TRUE. Produza uma tabela verdade para a porta maioria de trs entradas
mostrado na Figura 1.41.
Figura 1.41 Porta maioria de trs entradas
Exerccio 1.74 A porta AND-OR (AO) de trs entradas mostrado na Figura 1.42 produz uma sada
TRUE se ambas A e B so TRUE, ou se C TRUE. Produza uma tabela verdade para esta porta.
Figura 1.42 Porta AND-OR de trs entradas
Exerccio 1.75 A porta OR-AND invertida de trs entradas (AOI), mostrada na Figura 1.43, produz
uma sada FALSE se C verdadeiro e A ou B so TRUE. Caso contrrio, produz uma sada TRUE.
Produza uma tabela verdade para esta porta.
Figura 1.43 Porta AND-OR_NOT de trs entradas
63
Exerccio 1.76 Existem 16 tabelas verdade diferentes para funes booleanas de duas variveis.
Liste cada uma destas tabelas verdade. D a cada uma um nome descritivo (tal como OR, NAND, e
assim por diante).
Exerccio 1.77 Quantas tabelas verdade diferentes existem para funes booleanas de N
variveis?
Exerccio 1.78 possvel atribuir nveis lgicos de modo que um dispositivo com as caractersticas
de transferncia apresentada na Figura 1.44 opere como um conversor? Se sim, quais so os nveis
HIGH e LOW de entrada e sada (VIL, VOL, VIH, e VOH) e as margens de rudo (NML e NMH)? Se no,
explique porque no.
Figura 1.44 Funo de transferncia DC
64
Exerccio 1.79 Repita o Exerccio 1.78 para as caractersticas de transferncia mostradas na Figura
1.45.
Exerccio 1.80 possvel atribuir nveis lgicos de modo que um dispositivo com as caractersticas
de transferncia apresentada na Figura 1.46 opere como um buffer? Se sim, quais so os nveis HIGH
e LOW de entrada e sada (VIL, VOL, VIH, e VOH) e as margens de rudo (NML e NMH)? Se no, explique
porque no.
65
Exerccio 1.81 Ben Bitdiddle inventou um circuito com as caractersticas de transferncia

mostrados na Figura 1.47 que ele gostaria de usar como buffer. Ser que vai funcionar? Porque sim
ou porque no? Ele gostaria de o anunciar como sendo compatvel com lgica LVCMOS e LVTTL. Pode
o buffer do Bem receber corretamente as entradas a partir dessas famlias lgicas? A sada pode fazer
o drive correto essas famlias lgicas? Explique.
66
Exerccio 1.82 Enquanto caminhava por um beco escuro, Ben Bitdiddle encontrou uma porta
de duas entradas cuja funo de transferncia mostrada na Figura 1.48. As entradas so A e B
e a sada Y.
(a) que tipo de porta lgica ele encontrou?

(b) quais so os nveis lgicos aproximados de HIGH e LOW?
67
Exerccio 1.83 Repita o Exerccio 1.82 para a Figura 1.49.
Exerccio 1.83 Esboce um circuito a nvel do transstor para as seguintes portas CMOS. Use
um nmero mnimo de transstores.
(a) porta NAND de quatro entradas
(b) porta OR-AND-NOT de trs entradas (ver Exerccio 1.75)
(c) porta NAND-OR de trs entradas (ver Exerccio 1.74)
Exerccio 1.84 Esboce um circuito a nvel do transstor para as seguintes portas CMOS. Use um
nmero mnimo de transstores.
(a) porta NOR de trs
(b) porta AND de trs entradas
(c) porta OR de duas entradas
68
Exerccio 1.85 Uma porta minoritria produz uma sada TRUE se, e somente se, menos da metade
de suas entradas so TRUE. Caso contrrio, produz uma sada FALSE. Esboce um circuito a nvel de
transstor para uma porta CMOS minoritria de trs entradas. Use um nmero mnimo de transstores.
Exerccio 1.86 Escreva uma tabela verdade para a funo desempenhada pela porta da Figura 1.50.
A tabela verdade deve ter duas entradas, A e B. Qual o nome desta funo?
Figura 1.50 Esquema mistrio
Exerccio 1.87 Escreva uma tabela verdade para a funo desempenhada pela porta da Figura 1.51.
A tabela verdade deve ter trs entradas, A, B, e C.
Figura 1.51 Esquema mistrio
69
Exerccio 1.88 Implemente as seguintes portas lgicas de trs entradas usando apenas portas
lgicas pseudo-nMOS. Estas portas recebem trs entradas, A, B e C. Utilize um nmero mnimo
de transstores.
(A) porta NOR de trs entradas
(B) porta NAND de trs entradas
(C) porta AND de trs entradas
Exerccio 1.89 A lgica Resistor-Transstor (RTL) usa transstores nMOS para puxar a sada da
porta a LOW e uma resistncia fraca para puxar a sada a HIGH quando nenhum dos caminhos
para a terra est cativo. A porta NOT construda utilizando um RTL mostrado na Figura 1.52.
Esboce uma porta NOR RTL de trs entradas. Use um nmero mnimo de transstores.
Figura 1.52 Porta RTL NOT
70
Questes de Entrevista
Estas perguntas foram feitas em entrevistas para trabalhos de projeto digital.
Pergunta 1.1 Desenhe um circuito a nvel do transstor para uma porta NOR CMOS de quatro
entradas.
Pergunta 1.2 O rei recebe 64 moedas de ouro em impostos, mas tem razes para acreditar que
uma falsa. Ele convoca-o para identificar a moeda falsa. O leitor tem uma balana que pode conter
moedas de cada lado. Quantas vezes o leitor precisa usar a balana para encontrar a moeda falsa mais
leve?
Pergunta 1.3 O professor, o assistente, o aluno de projeto digital, e o calouro precisam atravessar
uma ponte frgil numa noite escura. A ponte to instvel que apenas duas pessoas podem
atravessar de uma vez. Eles tm apenas uma lanterna entre eles e a extenso muito longa para
lanar a lanterna, ento algum deve lev-lo de volta para as outras pessoas. O caloiro pode
atravessar a ponte em 1 minuto. O estudante de projeto digital pode atravessar a ponte em 2 minutos.
O assistente pode atravessar a ponte em 5 minutos. O professor que sempre se distrai e leva 10
minutos para atravessar a ponte. Qual o tempo mais rpido para fazer chegar todos ao outro lado
da ponte?
71
72
Captulo dois Projeto de Lgica Combinatria
2. Projeto de Lgica Combinatria

2.1. INTRODUO
Na eletrnica digital, um circuito uma rede que processa variveis de valores discretos. Um circuito pode
ser visto como uma caixa preta, mostrada na Figura 2.1, com
Um ou mais terminais de entrada de valor discreto
Um ou mais terminais de sada de valor discreto
Uma especificao funcional descrevendo a relao entre as entradas e sadas
Uma especificao temporal descrevendo o atraso entre as mudanas nas entradas e as respostas
nas sadas.
Olhando dentro da caixa preta, os circuitos so compostos de ns e elementos. Um elemento por si s
um circuito com entradas, sadas e uma especificao. Um n um fio, cuja tenso transmite um valor varivel
discreto. Os ns so classificados como entrada, sada ou interno. As entradas recebem valores vindos do
mundo externo. As sadas entregam os valores para o mundo externo. Os fios que no so nem entradas nem
sadas so chamados de ns internos.
Figura 2.1 Circuito representado como uma caixa preta com entradas, sadas e especificaes
73
Figura 2.2 Elementos e ns
A Figura 2.2 ilustra um circuito com trs elementos, E1, E2 e E3, e seis ns. Os ns A, B e C so
entradas. Y e Z so sadas. n1 um n interno entre E1 e E3.
Os circuitos digitais so classificados como combinatrios ou sequenciais. A sada de um circuito
combinatrio depende apenas do valor atual das entradas; por outras palavras, ele combina os valores
atuais das entradas para determinar o valor da sada. Por exemplo, uma porta lgica um circuito
combinatrio. A sada de um circuito sequencial depende tanto dos valores atuais de entrada quanto
dos anteriores; por outras palavras, ele depende da sequncia de entrada. Um circuito combinatrio
no possui memria, mas um circuito sequencial tem memria. Este Captulo foca os circuitos
combinatrios, e o Captulo 3 examina os circuitos sequenciais.
A especificao funcional de um circuito combinatrio expressa os valores de sada em termos dos
valores atuais das entradas. A especificao temporal de um circuito combinatrio consiste nos limites
inferiores e superiores do atraso da entrada para a sada. Iremos, inicialmente, nos concentrar nas
especificaes funcionais e, ento, retornar para as especificaes temporais mais tarde neste
Captulo.
A Figura 2.3 mostra um circuito combinatrio com duas entradas e uma sada. esquerda da figura
esto as entradas, A e B, e direita est a sada, Y. O smbolo dentro da caixa indica que o circuito
implementado utilizando apenas lgica combinatrio. Nesse exemplo, a funo F especificada como
74
OR: Y = F(A,B) = A + B. Literalmente, podemos dizer que a sada Y uma funo de duas entradas, A e
B, nomeada Y = A OR B.
A Figura 2.4 mostra duas possveis implementaes para o circuito lgico combinatrio da Figura 2.3
Como veremos repetidamente ao longo deste livro, existem muitas implementaes possveis para
uma nica funo. O leitor quem escolhe qual utilizar, dados os blocos digitais sua disposio e as
suas limitaes de projeto. Essas limitaes incluem frequentemente rea, velocidade, potncia e Figura 2.3 Bloco de circuito
tempo de projeto. combinatrio
A Figura 2.5 mostra um circuito combinatrio com mltiplas sadas. Este circuito combinatrio
particular chamado de full adder e iremos v-lo novamente na Seo 5.2.1. As duas equaes
especificam a funo das sadas, S e Cout, em termos das entradas, A, B e Cin.
A fim de simplificar as ilustraes, muitas vezes utilizamos uma linha nica cortada por uma barra
para indicar um barramento, um pacote de vrios sinais. O nmero especifica quantos sinais existem
no barramento. Por exemplo, a Figura 2.6 (a) representa um bloco de lgica combinatria com trs
entradas e duas sadas. Se o nmero de bits no tiver importncia ou for bvio, a barra pode ser
mostrada sem o nmero. A Figura 2.6 (b) indica dois blocos de lgica combinatria com um nmero Figura 2.4 Duas implementaes OR
arbitrrio de sadas de um bloco servindo como entrada para o segundo bloco.
As regras da associao combinatria dizem-nos como podemos construir um grande circuito
combinatrio a partir de elementos combinatrios menores.
Um circuito dito combinatrio se ele for constitudo por elementos de circuitos interconectados
de tal modo que:
Todos os elementos do circuito so combinatrios. Figura 2.5 Circuito combinatrio de
Todos os ns do circuito so tambm designados como uma entrada ou conectados a mltiplas sadas
exatamente um terminal de sada de um elemento do circuito.
O circuito no contm caminhos cclicos: todos os caminhos atravs do circuito visitam cada
n do circuito no mximo uma vez.
75
Exemplo 2.1 CIRCUITOS COMBINATRIOS

Quais dos circuitos na Figura 2.7 so circuitos combinatrios, de acordo com as regras da composio
combinatrio?
Soluo: O circuito (a) combinatrio. Sendo construdo a partir de dois elementos de circuitos
combinatrios (inversores I1 e I2). Tem trs ns: n1, n2 e n3. n1 a entrada para o circuito e para I1; n2 um
n interno, sada de I1 e entrada de I2; n3 a sada do circuito e de I2. (b) no um circuito combinatrio,
pois existe um caminho cclico: a sada da funo XOR realimenta uma das entradas. Consequentemente, um
Figura 2.6 Notao de barra para caminho cclico, partindo de n4, passa atravs da porta XOR em direo a n5, que retorna a n4. (c)
mltiplos sinais combinatrio. (d) no combinatrio, pois o n n6 est conectado aos terminais de sada tanto de I3 quanto
de I4. (e) combinatrio, ilustrando dois circuitos combinatrios conectados formando um circuito
combinatrio maior. (f) no obedece s regras da associao combinatria pois existe um caminho cclico
atravs dos dois elementos. Dependendo das funes dos elementos, ele pode ser ou no um circuito
combinatrio.
Figura 2.7 Circuitos de exemplo
76
Grandes circuitos como microprocessadores podem ser muito complicados, ento utilizamos os
princpios do Captulo 1 para gerir a complexidade.
Visualizando o circuito como uma caixa preta com uma funo e interface bem definida uma
aplicao de abstrao e modularidade. Construindo o circuito principal atravs de circuitos menores
uma aplicao de hierarquia. As regras de composio combinatria so aplicaes de disciplina.
A especificao funcional de um circuito combinatrio usualmente expressa atravs de uma tabela
verdade ou equao Booleana. Nas prximas sees, ns descreveremos como derivar uma equao
Booleana a partir de qualquer tabela verdade, e como utilizar a lgebra Booleana e os mapas de Karnaugh
para simplificar equaes. Mostraremos como implementar estas equaes utilizando portas lgicas e
como analisar a velocidade destes circuitos.
2.2. EQUAES BOOLEANAS

Equaes Booleanas lidam com variveis que so TRUE ou FALSE, sendo, portanto, perfeitas para
descrever a lgica digital. Esta Seo define algumas terminologias comumente utilizadas em equaes
Booleanas, e mostra como escrever uma equao Booleana para qualquer funo lgica, baseada na sua
tabela verdade.
2.2.1. Terminologia
O complemento de uma varivel A seu inverso, . A varivel ou o seu complemento so chamados
, so literais. Chamamos A de forma verdadeira da varivel e A
literais. Por exemplo, , , de forma
complementar; forma verdadeira no significa que A tem valor TRUE, mas meramente que A no
possui uma barra sobre ele.
A funo lgica AND de uma ou mais variveis literais chamada de produto. , e so todos
produtos de uma funo de trs variveis. Um mintermo um produto envolvendo todas as entradas da
funo. um mintermo para uma funo de trs variveis A, B e C, mas no , pois no envolve
C. Similarmente, a unio OR de uma ou mais variveis literais chamada de soma. Um maxtermo a
77
soma envolvendo todas as entradas da funo. + + um maxtermo para uma funo de trs variveis
A, B e C.
A ordem de operao importante na interpretao de equaes Booleanas. Y = A + BC significa Y =
(A OR B)AND C ou Y = A OR (B AND C)? Nas equaes Booleanas, a funo NOT tem a mxima
precedncia, seguida pela funo AND e depois OR. Da mesma forma que nas equaes comuns, os produtos
so realizados antes das somas. Portanto, a equao lida como Y = A OR (B AND C). A equao 2.1 mostra
outro exemplo da ordem de operaes.
+
= (()) + ((
)) (2.1)
2.2.2. Forma de Soma de Produtos

Uma tabela verdade com N entradas contm 2 linhas, uma para cada possvel valor da entrada. Cada
linha na tabela verdade associada a um mintermo que mostra o sinal lgico TRUE para aquela linha. A
Figura 2.8 mostra uma tabela verdade com duas entradas, A e B. Cada linha mostra o seu mintermo
Figura 2.8 Tabela verdade e correspondente. Por exemplo, o mintermo para a primeira linha , pois TRUE quando A = 0 e B = 0.
mintermos Os mintermos so numerados partindo de 0; a linha de cima corresponde ao mintermo 0, 0 , a prxima
linha corresponde ao mintermo 1, 1 , e assim por diante.
Podemos escrever uma equao Booleana para qualquer tabela verdade somando cada um dos
mintermos para o qual a sada Y possui nvel lgico TRUE. Por exemplo, na Figura 2.8, existe apenas uma
linha (ou mintermo) para o qual a sada Y verdadeira (circulado em azul). Portanto, = . A Figura 2.9
mostra uma tabela verdade com mais de uma linha para as quais a sada TRUE. A soma de cada mintermo
circulado resulta em = + .
Esta denominada a forma cannica soma de produtos de uma funo pois a sada igual soma (OR)
dos produtos (AND formando mintermos). Apesar de existirem muitas maneiras de se escrever a mesma
Figura 2.9 Tabela verdade com funo, tal como = + , iremos classificar os mintermos na mesma ordem pela qual aparecem na
vrios mintermos TRUE tabela verdade, de tal modo que sempre escreveremos a mesma expresso Booleana para uma mesma
tabela verdade.
78
A forma de soma de produtos cannicos pode tambm ser escrita na notao sigma, utilizando-se o
smbolo de somatrios, . Com essa notao, a funo da Figura 2.9 pode ser reescrita como:
Forma Cannica apenas uma palavra

(, ) = (1 , 3 ) ou chique para denominar forma padro. O
leitor pode utilizar esse termo para
(2.2)
impressionar seus amigos e para
(, ) = (1,3) amedrontar seus inimigos!
Exemplo 2.2 FORMA DE SOMA DE PRODUTOS

Ben Bitdiddle est fazendo um piquenique. Ele no ir aproveitar se chover ou se houver formigas.
Projete um circuito que ir ter sada TRUE apenas se Ben aproveitar o piquenique.
Soluo: Primeiro, defina as entradas e as sadas. As entradas so A e R, que indicam se existem formigas
e se est chovendo, respectivamente. A ser TRUE se houver formigas e FALSE se no houver. Da mesma
forma, R TRUE se chover, e FALSE se o sol sorrir sobre Ben. A sada E o aproveitamento do piquenique
por Ben. E TRUE se Ben aproveitar o piquenique e FALSE se ele no aproveitar. A Figura 2.10 mostra a
tabela verdade para a experincia de Ben no piquenique.
Utilizando a forma de soma de produtos cannicos, escrevemos a equao como: = ou =

(0). Podemos construir a equao utilizando dois inversores e a porta AND de duas entradas mostrada
na Figura 2.11 (a). O leitor pode reparar que essa tabela verdade a da funo NOR mostrada na Seo
1.5.5: = NOR =
+ . A Figura 2.11 (b) mostra a implementao da funo NOR. Na Seo 2.3,
mostraremos que essas duas equaes, e
+ , so equivalentes. Figura 2.10 Tabela verdade de Ben
79
A forma de soma de produtos d uma equao Booleana para qualquer tabela verdade com qualquer nmero
de variveis. A Figura 2.12 mostra uma tabela verdade com trs entradas de valores aleatrios. A forma de soma
de produtos dessa funo lgica :
= + + ou
(2.3)
= (0,4,5)
Infelizmente, a forma de soma de produtos no gera necessariamente uma equao simples. Na Seo 2.3
mostraremos como escrever a mesma funo utilizando-se termos menores.
2.2.3. Forma de Produto de Somas
Um modo alternativo de expressar funes Booleanas a forma cannica de produto de somas. Cada linha da
tabela verdade corresponde ao maxtermo que FALSE para aquela linha. Por exemplo, o maxtermo da primeira
Figura 2.11 Circuito de Ben linha de uma tabela verdade de duas entradas (A+B), pois (A+B) FALSE quando A=0, B=0. Podemos escrever
uma equao Booleana para qualquer circuito diretamente da sua tabela verdade como uma funo AND de cada
um dos maxtermos para o qual a sada FALSE. A forma cannica do produto de somas pode tambm ser escrita
na notao pi, utilizando-se o smbolo matemtico para produto, .
Exemplo 2.3 FORMA DE PRODUTO DE SOMAS

Escreva uma equao na forma de produto de somas para a tabela verdade na Figura 2.13.
Soluo: A tabela verdade possui duas linhas nas quais a sada FALSE. Portanto, a funo pode ser escrita na
forma de produto de somas como = ( + ) ( + ) ou, utilizando a notao pi, = (0 , 2 ) ou ainda =
(0,2). O primeiro maxtermo, ( + ), garante que Y = 0 para A = 0, B = 0, pois qualquer valor AND 0 igual a 0.
Figura 2.12 Tabela verdade aleatria Da mesma forma, o segundo maxtermo, ( + ), garante que Y = 0 para A = 1, B = 0. A Figura 2.13 a mesma
de trs entradas tabela verdade da Figura 2.9, mostrando que a mesma funo pode ser escrita em mais do que uma forma.
80
De forma similar, a equao Booleana para o piquenique do Ben (Figura 2.10) pode ser escrita na
forma de produto de somas apenas circulando-se as trs linhas com 0s, obtendo-se =
( + )( + ) ( + ) ou = (1,2,3). Essa forma mais feia do que a equao na forma de soma
de produtos, = , mas as duas equaes so logicamente equivalentes.
A soma de produtos produz uma equao mais curta quando a sada TRUE em apenas algumas
linhas de uma tabela verdade; o produto das somas mais simples quando a sada FALSE em apenas
algumas linhas de uma tabela verdade.
Figura 2.13 Tabela verdade com
2.3. LGEBRA BOOLEANA vrios maxtermos FALSE
Na Seo anterior, aprendemos como escrever uma expresso Booleana a partir de uma tabela
verdade. No entanto, esta expresso no necessariamente leva ao conjunto mais simples de portas
lgicas. Do mesmo modo que o leitor pode utilizar a lgebra para simplificar equaes matemticas,
tambm pode utilizar a lgebra Booleana para simplificar equaes Booleanas. As regras da lgebra
Booleana so muito parecidas com as da lgebra comum, em alguns casos at mais simples, pois as
variveis possuem apenas dois valores possveis: 0 ou 1.
A lgebra Booleana baseada num conjunto de axiomas que assumiremos estarem corretos.
Axiomas no so provados, no mesmo sentido em que uma definio no pode ser provada. Com base
nesses axiomas, provamos todos os teoremas da lgebra Booleana.
81
Tabela 2.1 Axiomas da lgebra Booleana
Estes teoremas tm grande significncia no sentido prtico, pois eles nos ensinam a como
simplificar a lgica para produzir circuitos menores e mais baratos.
Os axiomas e teoremas da lgebra Booleana obedecem ao sentido da dualidade. Se os smbolos
Figura 2.14 Teorema da Identidade 0 e 1 e os operadores (AND) e + (OR) so inter-relacionados, a declarao ainda ser correta.
em hardware: (a) T1, (b) T1 Utilizamos o smbolo () para denotar o dual de uma declarao.
2.3.1. Axiomas
A Tabela 2.1 mostra os axiomas da lgebra Booleana. Estes cinco axiomas e seus duais definem
as variveis Booleanas e os significados de NOT, AND e OR. O axioma A1 declara que uma varivel
Booleana 0 se ela no for 1. O axioma dual A1 declara que a varivel 1 se ela no for 0. Juntos,
A1 e A1 dizem que estamos a trabalhar num campo binrio ou Booleano de zeros e uns. Os
axiomas A2 e A2 definem a operao NOT. Os axiomas A3 at A5 definem AND; seus duais, A3 a
Figura 2.15 Teorema do elemento A5, definem OR.
nulo em hardware: (a) T2, (b) T2
82
Tabela 2.2 Teoremas Booleanos de uma varivel
Figura 2.16 Teorema da

Idempotncia em hardware: (a) T3,
(b) T3
2.3.2. Teoremas de uma Varivel

Os teoremas T1 a T5 na Tabela 2.2 descrevem como simplificar equaes envolvendo uma varivel.
O teorema da identidade, T1, declara que para qualquer varivel Booleana B, B AND 1 = B. O seu
dual declara que B OR 0 = B. Em hardware, como mostrado na Figura 2.14, T1 significa que se uma das
Figura 2.17 Teorema da involuo:
duas entradas de uma porta AND sempre 1, podemos remover a porta AND e substitu-la por um fio
T4
conectado a varivel B. Da mesma forma, T1 significa que se uma das duas entradas de uma porta OR
sempre 0, podemos substituir a porta OR por um fio conectado B. Em geral, portas lgicas custam
dinheiro, potncia e atraso, ento, substituir uma porta por um fio tem os seus benefcios.
O teorema do elemento nulo, T2, diz que B AND 0 sempre igual a 0. Portanto, 0 chamado de
elemento nulo para a operao AND, pois ele sempre anula o efeito de qualquer outra entrada. Seu
dual declara que B OR 1 sempre igual a 1. Portanto, 1 o elemento nulo para a operao OR. Em
hardware, como mostrado na Figura 2.15, se uma entrada de uma porta AND 0, podemos substituir
a porta AND por um fio com nvel logico LOW (0). Da mesma forma, se uma das entradas de um OR for
1, podemos substituir a porta OR por um fio conectado ao nvel lgico HIGH (1).
A idempotncia, T3, diz que uma varivel AND ela prpria igual a ela. Da mesma forma, uma
varivel OR ela prpria igual a ela mesma. O teorema recebe este nome a partir do latim: idem (igual) Figura 2.18 Teorema do
e potent (potncia). A operao retorna a mesma coisa que recebe. A Figura 2.16 mostra que este complemento em hardware: (a) T5,
(b) T5
teorema novamente permite a substituio de uma porta por um fio.
83
A involuo, T4, um modo rebuscado de dizer que complementar uma varivel duas vezes resulta na
varivel original. Na eletrnica digital, dois errados resultam num certo. Duas portas inversoras em srie
logicamente cancelam uma outra e so logicamente equivalentes a um fio, como mostrado na Figura
2.17. O dual de T4 ele prprio.
O teorema do complemento, T5 (Figura 2.18), declara que uma varivel AND e o seu complemento 0
(pois uma delas precisa ser 0). Por dualidade, uma varivel OR e o seu complemento 1 (porque uma delas
precisa ser 1).
O teorema do elemento nulo leva a
expresses estranhas que so verdade. Isso 2.3.3. Teoremas com muitas Variveis
particularmente perigoso quando utilizado Os teoremas do T6 ao T12 na Tabela 2.3 descrevem como simplificar equaes envolvendo mais do que
por pessoas que enviam anncios: O LEITOR uma varivel Booleana.
GANHAR UM MILHO DE DLARES ou ns
lhe enviaremos uma escova de dentes pelo A comutatividade e associatividade, T6 e T7, trabalham do mesmo modo que na lgebra tradicional.
correio. (O leitor provavelmente receber Por comutatividade, a ordem de entrada para uma funo AND ou OR no afeta o valor da sada. Por
uma escova de dentes. associatividade, os agrupamentos especficos das entradas no afetam os valores da sada.
O teorema da distributividade, T8, o mesmo da lgebra tradicional, mas o seu dual, T8, no . Atravs
de T8, AND se distribui por cima de OR, e por T8, OR se distribui por cima de AND. Na lgebra tradicional,
a multiplicao se distribui antes da adio mas a adio no se distribui por cima da multiplicao, de
modo que (B + C). (B + D) B + (C. D).
Os teoremas T9 a T11 nos permitem eliminar variveis redundantes. Pensando um pouco, o leitor ser
capaz de se convencer que estes teoremas esto corretos.
O Teorema de De Morgan, T12, uma ferramenta particularmente poderosa no projeto de sistemas
digitais. O teorema mostra que o complemento do produto de todos os termos igual ao produto do
84
complemento de cada termo. Da mesma forma, o complemento da soma de todos os termos igual ao
produto dos complementos de cada termo.
Tabela 2.3 Teoremas Booleanos para muitas variveis
Augustus De Morgan, morte: 1871.

Matemtico Britnico, nascido na
ndia. Cego de um olho. Seu pai
morreu quando ele tinha 10 anos.
Entrou no Trinity College, Cambridge,
De acordo com o teorema de De Morgan, uma porta NAND equivalente a uma porta OR com suas com 16 anos, e foi contratado como
entradas invertidas. Similarmente, uma porta NOR equivalente a uma porta AND com suas entradas professor de matemtica da
invertidas. A Figura 2.19 mostra as portas equivalentes de De Morgan para portas NAND e NOR. Os dois recentemente fundada London
smbolos mostrados para cada funo so chamados duais. Eles so logicamente equivalentes e podem University com 22 anos. Escreveu
ser utilizados de modo intercambivel. largamente sobre muitos assuntos
O crculo, smbolo da inverso, chamado bolha ou bola. Intuitivamente, o leitor pode imaginar que, matemticos, incluindo lgica, lgebra
empurrando a bolha atravs da porta lgica faz com que ela saia pelo outro lado e mude o formato da e paradoxos. A cratera lunar de De
porta lgica de AND para OR ou vice-versa. Por exemplo, a porta NAND na Figura 2.19 consiste num corpo Morgan tem esse nome em
de porta AND com uma bolha na sada. Empurrar a bolha para a esquerda resulta num corpo de porta OR homenagem a ele. Ele props um
com bolhas nas entradas. As regras fundamentais para esses empurres de bolha so: enigma para o ano de seu nascimento:
Eu tinha x anos no ano x.
85
Figura 2.19 Portas equivalentes de De Morgan
Empurrando bolhas para trs (partindo da sada) ou para frente (partindo da entrada) muda o corpo
da porta logica de AND para OR ou vice-versa.
Empurrar uma bolha da sada de volta para as entradas coloca as bolhas em todos os terminais de
entrada.
Empurrar bolhas em todos os terminais de entrada em direo a sada coloca uma bolha no terminal
Figura 2.20 Tabela verdade
de sada.
mostrando e
A Seo 2.5.2 utiliza os empurres de bolha no auxlio da anlise de circuitos.
Exemplo 2.4 DERIVANDO A FORMA DE PRODUTO DE SOMAS
A Figura 2.20 mostra a tabela verdade para uma funo Booleana e seu complemento . Usando
o Teorema de De Morgan, derive a forma cannica de produto de somas de para a forma de soma de
produtos de .
Figura 2.21 Tabela verdade
Soluo: a Figura 2.21 mostra os mintermos (circulados) contidos em . A forma cannica de soma de
mostrando os mintermos para
produtos de :
86
= + (2.4)
Tomando o complemento de ambos os lados da equao e aplicando-se o Teorema de De Morgan
duas vezes, obtemos:
= =
+ = (
)( ) = ( + )( + ) (2.5)
2.3.4. A Verdade por Detrs de Tudo

Um leitor curioso provavelmente se perguntaria como provar que este teorema verdade. Na
lgebra Booleana, a prova de teoremas com um nmero finito de variveis fcil: apenas mostre que
o teorema vlido para todos os valores possveis para essas variveis. Este mtodo chamado
induo perfeita e pode ser realizado com uma tabela verdade.
Exemplo 2.5 PROVANDO O TEOREMA UTILIZANDO A INDUO PERFEITA

Prove o teorema T11 da Tabela 2.3.
Soluo: Verifique ambos os lados da equao para todas as oito combinaes de B, C e D. A tabela
verdade na Figura 2.22 ilustra essas combinaes. Como + + = para todos os casos,
o teorema provado.
Figura 2.22 Prova da tabela verdade

(T11)
87
2.3.5. Simplificando Equaes

Os teoremas da lgebra Booleana nos ajudam a simplificar equaes Booleanas. Por exemplo,
considere a expresso na forma de soma de produtos a partir da tabela da Figura 2.9: = + .
Pelo teorema T10, essa equao simplificada para = . Isto pode parecer bvio quando se observa
a tabela verdade. Em geral, mltiplos passos podem ser necessrios para simplificar equaes mais
complexas.
O princpio bsico da simplificao de equaes na forma de soma de produtos combinar os termos
utilizando-se a relao + = , onde P pode ser qualquer implicante. At quando uma equao
pode ser simplificada? Definimos que uma equao na forma de soma de produtos deve ser minimizada
se forem utilizados o mnimo possvel de implicantes. Se existem muitas equaes com o mesmo nmero
de implicantes, o implicante mnimo ser aquele com o menor nmero de literais.
Um implicante chamado de implicante primo se ele no pode ser combinado com nenhum outro
implicante na equao, a fim de formar um novo implicante com um nmero menor de literais. Os
implicantes numa equao mnima devem ser todos implicantes primos. Por outro lado, eles podem ser
combinados para reduzir o nmero de literais.
Exemplo 2.6 MINIMIZAO DE EQUAES
Minimize a equao 2.3: + + .

Soluo: Comeamos com a equao original e ento aplicamos os teoremas Booleanos passo-a-passo,
como mostrado na Tabela 2.4.
Simplificamos completamente a equao at este ponto? Vamos olhar mais de perto.
Da equao original, os mintermos e diferem em apenas uma varivel, A. Ento

combinamos os mintermos para formar . No entanto, se olharmos para a equao original,
notaremos que os ltimos dois mintermos, e tambm diferem em apenas um literal ( e ).
Assim, usando o mesmo mtodo, podemos combinar esses dois mintermos para formar o mintermo
. Dizemos que os implicantes e compartilham o mintermo .
88
Ento, estamos bloqueados e apenas podemos simplificar apenas um dos pares de mintermos, ou
podemos simplificar os dois? Utilizando o teorema da idempotncia, podemos duplicar os termos
quantas vezes quisermos: = + + + Utilizando este princpio, simplificamos a equao
completamente para os seus dois implicantes primos, e , como mostrado na Tabela 2.5.
Tabela 2.4 Minimizao de equaes
Tabela 2.5 Minimizao melhorada de equaes
89
Apesar de ser um pouco contra intuitivo, expandir um implicante (por exemplo, transformando
em + ) pode ser til na minimizao de equaes. Fazendo isso, o leitor pode repetir um
dos mintermos expandidos para ser combinado com outro mintermo.
O leitor pode ter notado que simplificar totalmente uma equao Booleana com os teoremas da
lgebra Booleana pode levar a certa tentativa e erro. A Seo 2.7 descreve um procedimento metdico
chamado mapa de Karnaugh que torna o processo mais simples.
Porque simplificar uma equao Booleana se ela continua logicamente equivalente? A
simplificao reduz o nmero de portas lgicas usadas para implementar fisicamente a funo,
deixando-a menor, mais barata e, possivelmente, mais rpida. A prxima Seo descreve como
implementar equaes Booleanas utilizando portas lgicas.
2.4. DA LGICA S PORTAS

Um esquemtico um diagrama de um circuito digital, que mostra os elementos e as suas
conexes. Por exemplo, o esquemtico na Figura 2.23 mostra uma possvel implementao de
hardware para a nossa funo lgica favorita, a equao 2.3:
= + +
Atravs do esboo de esquemticos num estilo consistente, podemos deixamo-los mais fceis de
ler e de encontrar defeitos. Geralmente, obedecemos s seguintes orientaes:
Entradas do lado esquerdo, ou acima do esquemtico.
Sadas do lado direito, ou abaixo do esquemtico.
Quando possvel, o sentido de orientao das portas deve ser da esquerda para a direita.
Utilizar fios retos melhor do que fios com vrias esquinas (fios irregulares fazem o leitor
gastar muito esforo mental seguindo os fios ao invs de pensar sobre o que o circuito faz).
Fios sempre so conectados numa juno T.
Um ponto no cruzamento entre fios indica que eles esto conectados entre si.
Cruzamento de fios num ponto significa que eles no esto conectados.
90

Figura 2.23 Esquemtico para = +
+

As ltimas trs orientaes so mostradas na Figura 2.24.

Qualquer equao Booleana na forma de soma de produtos pode ser desenhada como um
diagrama esquemtico de um modo sistemtico semelhante Figura 2.23. Primeiramente, desenhe
as colunas para as entradas. Ponha inversores em colunas adjacentes para disponibilizar as entradas
complementadas, se necessrio. Desenhe as linhas e as portas AND para cada um dos mintermos. Figura 2.24 Ligaes de fios
Em seguida, para cada sada, desenhe uma porta OR conectada aos mintermos relacionados com
aquela sada. Esse estilo chamado array lgico programvel, pois os inversores, portas AND e OR
so colocados num estilo sistemtico. Esse tipo de desenho melhor discutido na Seo 5.6.
A Figura 2.25 mostra uma implementao da equao simplificada que encontramos utilizando
lgebra Booleana no exemplo 2.6. Note que o circuito simplificado possui significativamente menos
hardware do que o circuito da Figura 2.23. Ele tambm mais rpido, pois utiliza portas com menos
entradas.
91
Podemos diminuir o nmero de entradas ainda mais (ainda que de apenas um inversor) tirando
vantagem das portas inversoras. Observe que uma porta AND com entradas invertidas. A Figura
2.26 mostra um esquemtico utilizando essa otimizao a fim de se eliminar o inversor em C. Lembre-
se que, pelo teorema de De Morgan, a porta AND com entradas inversoras equivalente a uma porta
NOR. Dependendo da tecnologia de implementao, pode ser mais barato utilizar a menor
quantidade possvel de portas ou ento dar preferncia a certos tipos de portas em relao a outras.
Por exemplo, NANDs e NORs so preferveis ao invs de AND e OR na implementao tipo CMOS.
Muitos circuitos possuem mltiplas sadas, cada uma delas computando uma funo Booleana
separada. Podemos escrever uma tabela verdade separada para cada sada, mas conveniente
escrever todas as sadas numa nica tabela verdade e ento desenhar um esquemtico para todas
elas.
Exemplo 2.7: CIRCUITOS DE MLTIPLAS SADAS

Figura 2.25 Esquemtico para =

+
O reitor, o chefe de departamento, o professor assistente e o chefe do departamento de
dormitrios utilizam o auditrio de tempos em tempos. Infelizmente, eles ocasionalmente entram
em conflito devido a alguns desastres, como quando a reunio do reitor para recolha de fundos
ocorreu ao mesmo tempo que a festa dos dormitrios. Alyssa P. Hacker foi chamada para projetar
um sistema de reserva de sala.
O sistema possui quatro entradas, 3 , , 0 , e quatro sadas, 3 , , 0. Estes sinais tambm
podem ser escritos como 3:0 e 3:0 . Cada usurio confirma a sua entrada, solicitando o auditrio
para o dia seguinte. O sistema confirma no mximo uma sada, garantindo o auditrio para o usurio
de maior prioridade. O reitor, que est pagando por esse sistema, demanda maior prioridade (3). O
chefe de departamento, professor assistente e chefe do departamento de dormitrios possuem
prioridade decrescente.
Escreva uma tabela verdade e as equaes Booleanas para este sistema. Desenhe o circuito que
desenvolva a funo.
Figura 2.26 Esquemtico usando
menos portas lgicas
92
Soluo: Esta funo chamada de circuito de prioridade de quatro entradas. Seu smbolo e sua
tabela verdade so mostrados na Figura 2.27.
Poderamos escrever cada sada na forma de soma de produtos e ento reduzir as equaes
utilizando lgebra Booleana. No entanto, as equaes simplificadas so claramente compreensveis
atravs da inspeo da descrio funcional (e tabela verdade) do sistema: 3 TRUE sempre que 3
for acionada, ento, 3 = 3 . 2 TRUE se 2 foi acionado e 3 no foi acionado, ento 2 = 3 2 .
1 TRUE se nenhuma das entradas de maior prioridade for acionada: 1 = 3
2 1 . E 0 TRUE
sempre que 0 for acionada, apenas. Portanto, 0 =
3
2 1 0 . O esquemtico mostrado na Figura
2.28. Um projetista experiente poderia implementar a lgica desse circuito por inspeo. Dada uma
especificao clara, simplesmente transformaria as palavras em equaes e as equaes em portas
lgicas.
Note que, se 3 acionado no circuito de prioridade, as sadas so aquelas, no interessando as

entradas (dont care). Ns utilizamos o smbolo X para descrever entradas que no interferem nos
valores das sadas. A Figura 2.29 mostra que a tabela verdade do circuito de prioridade de quatro
entradas se torna muito menor considerando-se os dont cares. A partir dessa tabela verdade, ns
podemos facilmente ler as equaes Boolenas na forma de soma de produtos apenas ignorando as
entradas com X. Dont cares podem tambm aparecer nas sadas das tabelas verdades, como veremos
na Seo 2.7.3.
2.5. LGICA COMBINATRIO MULTI-NVEL

A lgica na forma de soma de produtos chamada lgica de dois nveis, pois consiste em literais
conectados a um nvel de portas AND, conectados, por sua vez, a um nvel de portas OR. Os projetistas, Figura 2.27 Circuito de prioridade de
muitas vezes, constroem circuitos com mais do que dois nveis de portas lgicas. Estes circuitos prioridade
combinatrios multi-nveis podem utilizar menos hardware do que seus equivalentes em dois nveis.
O mtodo dos empurres de bolha especialmente til na anlise e projeto de circuitos multi-nvel.
93
2.5.1. Reduo de Hardware

Algumas funes lgicas necessitam de uma enorme quantidade de hardware quando construdas
utilizando-se a lgica de dois nveis. Um exemplo notvel a funo XOR de mltiplas variveis. Por
exemplo, considere o projeto de uma porta XOR de trs entradas utilizando as tcnicas de dois nveis
que estudmos at agora.
Lembre-se que uma XOR de N entradas produz uma sada de valor TRUE quando um nmero par
de entradas TRUE. A Figura 2.30 mostra a tabela verdade para uma funo XOR de trs entradas,
com as linhas circuladas que produz Figura 2.30 em sadas TRUE. A partir da tabela verdade obtemos
a equao Booleana na forma de soma de produtos mostrada na equao 2.6. Infelizmente, no
Figura 2.28 Esquemtico do circuito possvel simplificar essa equao para um nmero menor de implicantes.
= + + + (2.6)
Por outro lado, = ( ) (prove o leitor, por induo perfeita, caso tenha
dvidas). Portanto, uma XOR de trs entradas pode ser construda a partir de portas XOR de duas
entradas em cascata, como mostrado na Figura 2.31.
Figura 2.29 Tabela verdade do

circuito de prioridade, com dont
care (X)
X um smbolo com mais do que um

significado, que significa "no importa" ou
"don't care" em tabelas verdade, e
"conteno" em simulao lgica (veja
Seo 2.6.1). Pense um pouco para no
confundir os significados. Alguns autores
utilizam D ou ? ao invs de "don't care"
para evitar ambiguidades.
Figura 2.30 XOR de trs entradas: (a) especificao funcional. (b) implementao lgica de dois
nveis
94
De modo similar, uma XOR de oito entradas necessitaria de 128 portas AND de oito entradas e uma
porta OR de 128 entradas para uma implementao de soma de produtos em dois nveis. Uma opo
melhor a utilizao de uma rvore de portas XOR de duas entradas, como mostrado na Figura 2.32.
Selecionar a melhor implementao multi-nvel para uma funo lgica especfica no um
processo simples. Mais ainda, melhor possui vrios significados: menor quantidade de portas, mais
rpido, menor tempo de projeto, menor custo, menor consumo de potncia. No Captulo 5, o leitor
ver que o melhor circuito num tipo de tecnologia no necessariamente o melhor noutro tipo. Por Figura 2.31 XOR de trs entradas:
utilizando XOR de duas entradas
exemplo, temos utilizado portas AND e OR, mas na tecnologia CMOS, NAND e NOR so mais eficientes.
Com alguma experincia, o leitor ir descobrir que pode criar um bom projeto multi-nvel atravs da
inspeo de vrios circuitos. O leitor ir desenvolver um pouco essa experincia conforme for
estudando os exemplos de circuito atravs deste livro. Conforme for aprendendo, explore vrias
opes de projeto e faa um balano entre eles. As ferramentas CAD (Computer-aided design) esto
disponveis para a consulta num grande espao de possveis projetos multi-nvel, para que encontre
algum que melhor se adapte s limitaes, dado os blocos disponveis.
2.5.2. Empurres de Bolha
O leitor deve se lembrar, da Seo 1.7.6, que nos circuitos CMOS as portas NAND e NOR so
preferveis sobre AND e OR. Porm, analisar por inspeo uma equao de um circuito multi-nvel com
NAND e NOR pode ser bem complicado. A Figura 2.33 mostra um circuito multi-nvel o qual a funo
no imediatamente clara atravs da inspeo. O mtodo dos empurres de bolha um modo til Figura 2.32 XOR de oito entradas
de redesenhar estes circuitos, para que as bolhas se cancelem e a funo possa ser determinada mais utilizando sete XOR de duas entradas
facilmente. A partir dos princpios da Seo 2.3.3, as orientaes para os empurres de bolhas so os
seguintes:
Comece nas sadas do circuito e trabalhe em direo s entradas;
Empurre qualquer bolha na sada de volta para a entrada, assim o leitor poder ler a
equao em termos da sada (por exemplo, ) ao invs do complemento da sada ().
95
Trabalhando no sentido contrrio, desenhe cada porta de tal forma que as bolhas se possam
cancelar. Se a porta atual tiver uma bolha na entrada, desenhe a porta precedente com uma bolha
na sada. Se a porta atual no tem uma bolha na entrada, desenhe a porta precedente sem
nenhuma bolha na sada.
A Figura 2.34 mostra como redesenhar a Figura 2.33 de acordo com as orientaes para os
Figura 2.33 Circuito multi-nvel empurres de bolha. Partindo da sada , a porta NAND possui uma bolha na sada que ns
utilizando NAND e NOR gostaramos de eliminar. Ns ento empurramos a bolha na sada de modo a formar uma porta OR
com entradas invertidas, mostrada na Figura 2.34 (a). Trabalhando para a esquerda, vemos que a
porta mais direita possui uma bolha na entrada que se cancela com a bolha de sada da porta
NAND do meio, no sendo necessrias mudanas nesse caso, como mostrado na Figura 2.34 (b). A
porta do meio no tem nenhuma bolha de entrada, por isso, transformamos a porta mais
esquerda para no ter nenhuma bolha de sada, como se mostra na Figura 2.34 (c). Agora todas as
bolhas no circuito se cancelam, exceto as entradas, de modo que a funo pode ser lida por
inspeo em termos de AND e OR de entradas normais ou complementadas: = + .
A fim de enfatizar esse ltimo ponto, a Figura 2.35 mostra um circuito logicamente equivalente
com aquele na Figura 2.34. As funes dos ns internos esto mostradas em azul. Como as bolhas
em srie se cancelam, ns podemos ignorar as bolhas na sada da porta central e numa das entradas
da porta mais direita a fim de produzir uma lgica equivalente ao circuito da Figura 2.35.
Exemplo 2.8 EMPURRES DE BOLHA PARA LGICA CMOS

Muitos projetistas pensam em termos de portas AND e OR, mas, supondo que o leitor gostaria
de implementar o circuito da Figura 2.36 utilizando lgica CMOS, que favorecem portas NAND e
NOR. Usando a tcnica dos empurres de bolha, converta o circuito para portas NAND, NOR e
inversoras.
Soluo: Uma soluo usando fora bruta seria apenas substituir cada porta AND por uma NAND e
Figura 2.34 Circuito utilizando um inversor, e cada porta OR, por uma NOR e um inversor, como mostrado na Figura 2.37. Isso
empurres de bolha requer oito portas. Note que o inversor desenhado com a bolha na sua frente, ao invs de atrs,
para enfatizar como a bolha pode ser cancelada com a porta inversora anterior.
96
Para obter uma soluo melhor, observe que bolhas podem ser adicionadas sada de uma porta
e entrada da porta seguinte sem que haja mudana na funo, como mostrado na Figura 2.38 (a).
A porta AND final convertida numa NAND e uma inversora, como mostrado na Figura 2.38 (b). Esta
soluo requer apenas cinco portas.
Figura 2.35 Lgica equivalente do

circuito utilizando empurres de
bolha
Figura 2.37 Circuito pobre utilizando NAND e NOR
Figura 2.38 Circuito melhorado utilizando NAND e NOR
2.6. XS E ZS, OH MEU DEUS! Figura 2.36 Circuito utilizando AND e

OR
A lgebra Booleana limitada aos valores 0 e 1. No entanto, circuitos reais podem tambm
possuir valores ilegais e flutuantes, representados simbolicamente por X e Z.
2.6.1. Valor Ilegal: X
O smbolo X indica que o n do circuito tem um valor desconhecido ou ilegal. Isso normalmente
acontece quando tanto 0 quanto 1 esto sendo direcionados para o mesmo n ao mesmo tempo. A
Figura 2.39 mostra um caso onde o n recebe tanto nvel HIGH quanto LOW. Esta situao,
chamada conteno, considerada um erro e deve ser evitada. A tenso verdadeira num n pode
ser algo entre 0 e , dependendo da fora das portas que esto transmitindo os nveis HIGH e
97
LOW. Essa regio considerada, quase sempre, uma zona proibida. A conteno pode requer uma
grande quantidade de potncia das portas em conflito, resultando em aquecimento do circuito e,
possivelmente, em danos.
Os valores X so, algumas vezes, utilizados por simuladores de circuito para indicar um valor no
inicializado. Por exemplo, se o leitor se esquecer de especificar o valor de uma entrada, o simulador
pode assumir que essa uma entrada X para prevenir problemas.
Figura 2.39 Circuito com conteno
Como mencionado na Seo 2.4, os projetistas de sistemas digitais tambm usam o smbolo X para
indicar valores dont care em tabelas verdade. Tenha certeza de que no est confundindo os dois
significados. Quando X aparece numa tabela verdade, ele indica que o valor da varivel presente na
tabela verdade no importante (tanto faz se 0 ou 1). Quando o X aparece num circuito, isso
significa que o n do circuito possui um valor desconhecido ou ilegal.
2.6.2. Valor Flutuante: Z
O smbolo Z indica que um n no est sendo alimentado nem por nvel HIGH nem LOW. O n
dito estar flutuante, em alta impedncia ou alta Z. Um equvoco tpico que um n flutuante ou no
alimentado o mesmo que um nvel lgico 0. Na realidade, um n flutuante pode ser 0, pode ser 1,
ou pode ser qualquer tenso entre esses dois nveis, dependendo da histria do sistema. Um n
flutuante nem sempre significa um erro no circuito, desde que outro elemento do circuito alimente
Figura 2.40 Buffer Tristate
o n com um nvel lgico vlido quando o valor desse n for relevante para a operao do circuito.
Um modo comum de se produzir um n flutuante esquecendo-se de alimentar uma entrada do
circuito, ou assumir que uma entrada no conectada o mesmo que uma entrada com nvel lgico
0. Esse erro pode fazer com que o circuito se comporte incorretamente, pois a entrada flutuante
muda aleatoriamente de 0 para 1. De fato, apenas tocar o circuito pode ser suficiente para disparar
a mudana, devido eletricidade esttica do corpo. Temos visto circuitos que operam corretamente
apenas enquanto o aluno mantm o dedo pressionado sobre o chip.
O buffer tristate, mostrado na Figura 2.40, possui trs possibilidades de estado de sada: HIGH (1),
LOW (0), e flutuante (Z). O buffer tristate possui uma entrada A, uma sada Y e um enable (ativao)
98
E. Quando o enable TRUE, o buffer tristate se comporta como um simples buffer, transferindo o
valor da entrada para a sada. Quando o enable FALSE, a sada flutuante (Z).
O buffer tristate na Figura 2.40 possui um enable ativo a alto. Isto , quando o enable HIGH(1),
o buffer est ativado. A Figura 2.41mostra um buffer tristate com um enable ativo a baixo. Quando
o enable LOW (0), o buffer est ativado. Mostramos que o sinal se torna ativo a baixo colocando-
se uma bolha no seu fio de entrada. Frequentemente indicamos uma entrada ativa a baixo
colocando uma barra sobre o seu nome, , ou colocando as letras bou baraps o seu nome,
ou _.
Os buffers tristate so normalmente utilizados em barramentos que conectam mltiplos chips. Figura 2.41 Buffer Tristate com
Por exemplo, um microprocessador, um controlador de vdeo e um controlador Ethernet poderiam Enable ativo a baixo
todos precisar se comunicar com a memria do sistema num computador pessoal. Cada chip pode
se conectar com o barramento de memria compartilhado utilizando-se buffers tristate, como
mostrado na Figura 2.42. Somente a um chip, por vez, permitido ativar o seu sinal de ativao para
transmitir um valor para o barramento. Os outros chips devem produzir sadas flutuantes para que
no causem conteno com o chip a comunicar com a memria. Qualquer chip pode ler a
informao do barramento compartilhado a qualquer momento. Estes barramentos tristate j
foram comuns. No entanto, nos computadores modernos, com maiores velocidades so possveis
atravs de links ponto a ponto, nos quais os chips so conectados entre si diretamente, ao invs de
um barramento compartilhado.
2.7. MAPAS DE KARNAUGH

Aps trabalhar com muitas minimizaes de equaes Booleanas utilizando lgebra Booleana, o
leitor vai perceber que, se no tomar cuidado, s vezes, ir terminar com uma equao
completamente diferente, ao invs de uma equao simplificada. Os mapas de Karnaugh (K-maps)
so um mtodo grfico para a simplificao de equaes Booleanas. Eles foram inventados em 1953
por Maurice Karnaugh, um engenheiro de telecomunicaes da Bell Labs. Os K-maps funcionam Figura 2.42 Buffer Tristate
bem para problemas com menos do que quatro variveis. Mais importante ainda, do informaes conectando mltiplos chips
sobre a manipulao de equaes Booleanas.
99
Recordamos que a lgica da minimizao envolve a combinao de termos. Dois termos contendo
um implicante e as formas real e complementar de alguma varivel so combinados para
Maurice Karnaugh, 1924-. Graduado
eliminar : + = . Os mapas de Karnaugh tornam estes termos combinveis fceis de ver,
como bacharel em fsica pela City College
colocando-os perto um do outro numa grade.
of New York em 1948 , recebeu seu Ph.D.
em fsica pela Yale em 1952. A Figura 2.43 mostra a tabela verdade e o K-map para uma funo de trs entradas. A linha de
Trabalhou na Bell Labs e na IBM de 1952 a cima do K-map d os trs valores possveis para as entradas A e B. A coluna da esquerda d as duas
1993 e como professor de cincia da possibilidades de valores para a entrada C. Cada quadrado no K-map corresponde a uma linha na
computao pela Polythecnic Unversity of tabela verdade, e contm o valor da sada naquela linha. Por exemplo, o quadrado do canto
New York de 1980 a 1999. superior esquerdo corresponde primeira linha da tabela verdade e indica que o valor de sada =
1 quando = 000. Assim como cada linha numa tabela verdade, cada quadrado no mapa de
Karnaugh representa um nico mintermo. A propsito de explicao, a Figura 2.43 (c) mostra os
mintermos correspondentes para cada quadrado no K-map.
Os cdigos de Gray foram patenteados

(Patente EUA 2.632.058) por Frank Gray,
um pesquisador da Bell Labs, em 1953.
Eles so especialmente teis em
codificadores mecnicos porque um
pequeno desalinhamento provoca um
erro em apenas um bit. Figura 2.43 Funo de trs entradas: (a) tabela verdade, (b) K-map, (c) K-map mostrando os
mintermos
Os cdigos Gray generalizam para
qualquer nmero de bits. Por exemplo, Cada quadrado, ou mintermo, difere do quadrado adjacente de uma mudana numa nica
uma sequncia de cdigo de Gray 3 bits : varivel. Isso significa que quadrados adjacentes compartilham todos os mesmos literais, exceto um,
000, 001, 011, 010,
o qual aparece em forma TRUE num quadrado e em forma complementar em outro. Por exemplo,
110, 111, 101, 100 os quadrados representando os mintermos e so adjacentes e diferem somente da
varivel C. O leitor pode ter notado que as combinaes e na linha de cima esto numa ordem
peculiar: 00,01,11,10. Essa ordem chamada de cdigo Gray. Ele difere da ordem binria comum
100
(00,01,10,11) em que entradas adjacentes diferem apenas numa varivel. Por exemplo, 01:11 apenas Lewis Carroll representava um enigma
mudam para 1, enquanto 01:10 poderia mudar de 1 para 0 e de 0 para 1. Portanto, escrever as relacionado na Vanity Fair em 1879.
combinaes em ordem binria poderia no produzir a propriedade desejada de quadrados
adjacentes diferindo apenas de uma varivel. "As regras do quebra-cabea so
bastante simples. Duas palavras so
O K-map tambm envolve. Os quadrados logo direita so efetivamente adjacentes aos propostas, com o mesmo
quadrados logo esquerda, nos quais diferem em apenas uma varivel, . Por outras palavras, o leitor comprimento; e o enigma consiste em
poderia pegar o mapa e enrol-lo num cilindro, ento juntar os finais do cilindro em forma de donut, as vincular interpondo outras
e ainda assim garantir que quadrados adjacentes iriam diferir em apenas uma varivel. palavras, cada um dos quais deve
2.7.1. Pensamento Circular diferir da prxima palavra em apenas
No K-map da Figura 2.43, apenas dois mintermos so apresentados na equao, e , como uma letra. Isto quer dizer, uma carta
indicado pelos uns na coluna da esquerda. Lendo os mintermos a partir do mapa de Karnaugh pode ser alterada em uma das
exatamente equivalente a ler as equaes na forma de soma de produtos a partir da tabela verdade. palavras apresentadas, em seguida,
uma letra da palavra assim obtida, e
assim por diante, at chegar outra
palavra dada. "
Por exemplo, SHIP para DOCK:
SHIP, SLIP, SLOP,
SLOT, SOOT, LOOT,
LOOK, LOCK, DOCK.
Figura 2.44 Minimizao com mapa de Karnaugh
Pode o leitor encontrar uma sequncia
Como antes, podemos utilizar a lgebra Booleana para minimizar as equaes na forma de soma mais curta?
de produtos.
= + = ( + ) = (2.7)
Os mapas de Karnaugh ajudam a fazer essa simplificao graficamente circulando os 1 em
quadrados adjacentes, como mostrado na Figura 2.44. Para cada crculo, escrevemos o implicante
correspondente. Lembre-se, da Seo 2.2, que um implicante o produto de um ou mais literais.
Variveis cujas formas verdadeiras e complementares esto ambas no crculo so excludas do
101
implicante. Nesse caso, a varivel tem tanto a sua forma verdadeira (1) quanto sua forma
complementar (0) no crculo, ento no a inclumos no implicante. Por outras palavras, Y TRUE
quando = = 0, independente de . Ento o implicante . O mapa de Karnaugh d a mesma
resposta que encontramos utilizando a lgebra Booleana.
2.7.2. Minimizao Lgica com Mapas de Karnaugh
Os mapas de Karnaugh fornecem num modo visual simples de minimizar a lgica. Simplesmente
circule todos os blocos retangulares com 1 no mapa, utilizando o menor nmero possvel de
crculos. Cada crculo deve ser o maior possvel. Ento tome os implicantes que foram circulados.
De modo mais formal, lembre-se que uma equao Booleana minimizada quando escrita
como uma soma do menor nmero possvel de implicantes principais. Cada crculo no mapa de
Figura 2.45 K-map para o exemplo Karnaugh representa um implicante. Os maiores crculos possveis so os implicantes principais.
2.9
Por exemplo, no mapa de Karnaugh da Figura 2.44, e so implicantes, mas no
implicantes principais. Apenas um implicante principal no mapa de Karnaugh. As regras para
se encontrar uma equao minimizada a partir de um K-map so as seguintes:
Utilize o menor nmero possvel de crculos necessrios para cobrir todos os 1;
Todos os quadrados dentro de cada crculo devem conter 1;
Cada crculo deve cobrir um bloco retangular que seja potncia de 2 isto , 1, 2, ou 4
quadrados em cada direo;
Cada crculo deve ser o maior possvel;
Um crculo pode dar as voltas ao redor das bordas do K-map;
Um 1 num K-map pode ser circulado mltiplas vezes, se isso permitir menos crculos serem
utilizados.
Figura 2.46 Soluo para o exemplo

2.9
102
Exemplo 2.9 MINIMIZAO DE UMA FUNO DE TRS VARIVEIS UTILIZANDO UM MAPA DE KARNAUGH
Suponha que ns temos a funo = (, , ) com o mapa de Karnaugh mostrado na Figura
2.45. Minimize a equao utilizando o mapa de Karnaugh.
Soluo: Circule os 1 no K-map usando a menor quantidade possvel de crculos, como mostrado na
Figura 2.46. Cada crculo no mapa de Karnaugh representa um implicante principal, e a dimenso de
cada crculo uma potncia de 2 (2x1 e 2x2). Formamos o implicante principal para cada crculo
escrevendo as variveis que aparecem no crculo apenas em condio verdadeiro ou apenas na forma
complementada.
Por exemplo, no crculo 2x1, as formas verdadeira e complementar de B esto includas no crculo, Figura 2.47 cone para o display
ento no inclumos B no implicante principal. No entanto, apenas a forma verdadeira de () e a decodificador de sete segmentos
forma complementada de ( ) esto nesse crculo, ento inclumos essas variveis no implicante
principal . Similarmente, o crculo 2x2 cobre todos os quadrados onde = 0, ento o implicante
principal .
Note como o quadrado superior direito (mintermo) coberto duas vezes para tornar o crculo do
implicante principal o maior possvel. Como ns vimos nas tcnicas de lgebra Booleana, isso equivale
a compartilhar o mintermo para reduzir o tamanho dos implicantes. Note tambm como o crculo
cobrindo quatro quadrados d a volta pelos lados do mapa de Karnaugh.
Exemplo 2.10 DECODIFICADOR DE DISPLAY DE SETE SEGMENTOS
Um decodificador de display de sete segmentos toma um dado de entrada de 4 bits 3:0 e produz
sete sadas que controlam diodos emissores de luz que mostram um dgito de 0 a 9. As sete sadas so
103
tambm chamadas de segmento a a g, ou , como definido na Figura 2.47. Os dgitos so

mostrados na Figura 2.48. Escreva uma tabela verdade para as sadas, e use os K-maps para encontrar
equaes Booleanas para as sadas e . Deve assumir que os valores ilegais de entrada (10-15)
produzem uma leitura em branco.
Soluo: A tabela verdade dada na Tabela 2.6. Por exemplo, uma entrada de 0000 deve ligar todos
os segmentos, exceto .
Cada uma das sete sadas uma funo independente de quatro variveis. O K-map para as sadas
e so mostrados na Figura 2.49. Lembre-se que quadrados adjacentes podem diferir em apenas
uma varivel, ento rotulamos as linhas e colunas na ordem do cdigo Gray: 00,01,11,10. Tenha o
cuidado de lembrar essa ordem quando inserir os valores das sadas nos quadrados.
Prximo passo, circular os implicantes principais. Utilize o menor nmero possvel de crculos
necessrios para cobrir todos os 1. Um crculo pode atravessar as bordas (vertical e horizontal), e
um 1pode ser circulado mais de uma vez. A Figura 2.50 mostra os implicantes principais e as
equaes Booleanas simplificadas.
Figura 2.48 Dgitos para o display decodificador de sete segmentos
Note que o conjunto mnimo de implicantes principais no nico. Por exemplo, a entrada 0000
no mapa de foi circulado tambm com a entrada 1000 para produzir o mintermo 2
1
0 . O

crculo poderia, alm disso, ter includo a entrada 0010, produzindo o mintermo 3 2 0 , como
mostrado com linhas pontilhadas na figura Figura 2.51.
104
A Figura 2.52 ilustra um erro comum no qual um implicante no principal foi escolhido para cobrir
o 1 no canto superior esquerdo. O mintermo poderia ter sido combinado com qualquer um dos 1
adjacentes para formar um crculo maior, como foi feito nas duas figuras anteriores.
Figura 2.49 Mapas de Karnaugh para e
Figura 2.50 Mapa de Karnaugh soluo para o exemplo 2.10
105
Figura 2.51 Mapa de Karnaugh alternativo para mostrando diferentes conjuntos de implicantes
principais
Tabela 2.6 Tabela verdade para o display decodificador de sete segmentos
106
2.7.3. Dont Cares

Lembre-se que entradas dont care numa tabela verdade foram introduzidas na Seo 2.4 para
reduzir o nmero de linhas na tabela quando algumas variveis no afetam as sadas. Elas so
indicadas pelo smbolo X, que significa que a entrada pode ser tanto 0 quanto 1.
Dont cares tambm aparecem em sadas de tabelas verdade quando a sada no importante ou
a combinao de entrada correspondente impossvel de ocorrer. Tais sadas podem ser tratadas
tanto como 0 quanto 1 pelo projetista.
Num mapa de Karnaugh, os X permitem ainda mais simplificar a lgica. Eles podem ser circulados
se ajudarem a cobrir os 1 com crculos maiores ou em quantidade menor, mas eles no precisam
ser circulados se no forem teis.
Figura 2.52 Mapa de Karnaugh

Exemplo 2.11 DECODIFICADOR DE DISPLAY DE SETE SEGMENTOS COM DONT CARES alternativo para mostrando
implicantes incorretos
Repita o exemplo 2.10 considerando que no nos importamos com os valores das sadas para as
entradas ilegais dos valores de 10 a 15.
Soluo: O K-map mostrado na Figura 2.53 com as entradas X representando dont cares. Como os
dont cares podem ser 0 ou 1, circulamos um dont care se ele nos permitir cobrir os 1 com crculos
maiores ou com menos crculos. Dont cares circulados so tratados como 1, enquanto dont cares
no circulados so 0. Observe como um quadrado 2x2 vai atravs dos quatro cantos ser circulado
para o segmento . O uso dos dont cares simplifica substancialmente a lgica.
2.7.4. A grande Imagem

A lgebra Booleana e os mapas de Karnaugh so dois mtodos de simplificao lgica. Em ltima
anlise, o objetivo encontrar um mtodo de baixo custo para a implementao de uma determinada
funo lgica.
107
Nas modernas prticas de engenharia, programas de computador chamados sintetizadores lgicos

produzem circuitos simplificados a partir de uma descrio de uma funo lgica, como ser visto no
Captulo 4. Para grandes problemas, os sintetizadores lgicos so muito mais eficientes que os
humanos. Para pequenos problemas, um humano com um pouco de experincia pode encontrar uma
boa soluo por inspeo. Nenhum dos autores nunca utilizou um mapa de Karnaugh na vida real
para resolver um problema prtico. Mas o conhecimento adquirido a partir dos princpios
fundamentais dos mapas de Karnaugh valioso. E os mapas de Karnaugh muitas vezes aparecem nas
entrevistas de emprego!
Figura 2.53 Solues de K-map com dont cares
108
2.8. BLOCOS COMBINATRIOS

A lgica combinatria frequentemente agrupada em blocos maiores a fim de se construrem
sistemas mais complexos. Essa uma aplicao do princpio de abstrao, escondendo os detalhes
a nvel das portas e enfatizando a funo do bloco. At aqui ns j estudamos trs destes blocos:
full adders (na Seo 2.1), circuitos de prioridade (na Seo 2.4) e decodificadores de displays de
sete segmentos (na Seo 2.7). Esta Seo introduz mais dois blocos normalmente utilizados:
multiplexadores e decodificadores. O Captulo 5 cobre outros blocos combinatrios.
2.8.1. Multiplexadores
Os multiplexadores esto entre os circuitos combinatrios mais normalmente utilizados. Eles
escolhem uma sada de entre muitas possveis entradas tendo por base o valor de um sinal de
seleo. Um multiplexador, s vezes, carinhosamente chamado de mux.
2.8.2. Multiplexadores 2:1
A Figura 2.54 mostra o esquemtico e a tabela verdade de um multiplexador 2:1 com duas Figura 2.54 Smbolo e tabela
entradas de dados, 0 e 1 , uma entrada de seleo e uma sada . O multiplexador escolhe entre verdade de um multiplexador 2:1
as duas entradas de dados baseada na entrada de seleo: se = 0, = 0 , e se = 1, = 1 .
tambm chamado de sinal de controle, pois controla o que o multiplexador faz.
Um multiplexador 2:1 pode ser construdo a partir da lgica de soma de produtos, como
mostrado na Figura 2.55. A equao Booleana para o multiplexador pode ser derivada com um mapa
de Karnaugh ou lida por inspeo ( 1 se = 0 AND 0 1 OR = 1 AND 1 1).
Alternativamente, os multiplexadores podem ser construdos a partir de buffers tristate como
mostrado na Figura 2.56. O controle do tristate arranjado de tal modo que, em todas as vezes,
exatamente um buffer tristate est ativo. Quando = 0, o tristate T0 est ativado, permitindo que
0 flua para . Quando = 1, o tristate T1 est ativado, permitindo que 1 flua para .
109
Figura 2.56 Multiplexador utilizando

buffers tristate
O curto-circuito em conjunto das sadas
de vrias portas lgicas tecnicamente
viola as regras para circuitos Figura 2.55 Implementao de um multiplexador 2:1 utilizando lgica de dois nveis
combinatrios dadas na Seo 2.1. Mas
porque exatamente uma das sadas
Multiplexadores Maiores
conduzida a qualquer momento, a Um multiplexador 4:1 possui quatro entradas de dados e uma sada, como mostrado na Figura
exceo permitida. 2.57. Dois sinais de seleo so necessrios para escolherem entre as quatro entradas. O
multiplexador 4:1 pode ser construindo utilizando-se a lgica de soma de produtos, tristates ou
mltiplos multiplexadores 2:1, como mostrado na Figura 2.58.
Os termos do produto ativando os tristates podem ser formados utilizando-se portas AND e
inversoras. Eles tambm podem ser formados usando um decodificador, o qual foi introduzido na
Seo 2.8.2.
Os Multiplexadores maiores, como os multiplexadores 8:1 ou 16:1, podem ser construdos
Figura 2.57 Multiplexador 4:1 expandindo-se os mtodos mostrados na Figura 2.58. Em geral, um multiplexador : 1 necessita de
110
log 2 linhas de seleo. Novamente, a melhor escolha de implementao depende da tecnologia

alvo.
Figura 2.58 Implementao de um

multiplexador 4:1 com lgica de
porta AND de duas entradas
Figura 2.59 Implementao de um multiplexador 4:1: (a) lgica de dois nveis; (b) tristates; (c)
hierrquica
Lgica do Multiplexador
Os multiplexadores podem ser usados como tabelas de pesquisa para realizar funes lgicas.
A Figura 2.59 mostra um multiplexador 4:1 utilizado para implementar uma porta AND de duas
entradas. As entradas, A e B, servem como linhas de seleo. As entradas de dados do
multiplexador so conectadas a 0 ou 1 de acordo com a linha correspondente da tabela verdade.
Em geral, um multiplexador de 2 entradas pode ser programado para realizar qualquer funo
lgica de entradas aplicando-se 0 ou 1 s entradas de dados apropriadas. De fato, atravs da
mudana nos dados de entrada, o multiplexador pode ser reprogramado para realizar uma funo
diferente.
111
Com um pouco de destreza, ns podemos cortar o tamanho de um multiplexador pela metade

utilizando apenas um multiplexador de 21 entradas para realizar qualquer funo lgica de
entradas. A estratgia deixar um dos literais, com 0 ou com 1, como entrada de dados do
multiplexador.
Para ilustrar este princpio, a Figura 2.60 mostra as funes AND e XOR implementadas com
multiplexadores 2:1. Comeamos a partir de uma tabela verdade comum, e combinamos pares de
linhas a fim de eliminar a varivel de entrada mais direita, expressando a sada em termos dessa
varivel. Por exemplo, no caso da AND, quando = 0, = 0, independentemente de . Quando =
1, = 0 se = 0 e = 1 se = 1, ento = . Ns ento usamos o multiplexador como uma
tabela de pesquisa de acordo com a nova, e menor, tabela verdade.
Figura 2.60 Lgica de multiplexador utilizando variveis de entrada
112
Exemplo 2.12 LGICA COM MULTIPLEXADORES
Alyssa P. Hacker precisa implementar a funo = + + para finalizar o seu projeto

snior, mas, quando ela olha para o seu kit de laboratrio, o nico componente que sobrou um
multiplexador 8:1. Como implementaria ela essa funo?
Soluo: A Figura 2.61 mostra a implementao de Alyssa utilizando um nico multiplexador 8:1. O
multiplexador age como uma tabela de pesquisa onde cada linha na tabela verdade corresponde a
uma entrada do multiplexador.
Exemplo 2.13 LGICA COM MULTIPLEXADORES, REPRISADA

A Alyssa ligou seu circuito uma ltima vez antes da apresentao final e explodiu o multiplexador
8:1 (ela acidentalmente o alimentou com 20 V ao invs de 5 V aps passar a noite em claro). Ela
implorou a seus amigos para que lhe cedessem componentes, e eles lhe deram um multiplexador
4:1 e uma porta inversora. Ela pode construir o seu circuito apenas com esses componentes? Figura 2.61 Circuito da Alyssa: (a)
tabela verdade; (b) implementao
Soluo: A Alyssa reduziu a sua tabela verdade para quatro linhas deixando a sada dependendo de do multiplexador
(ela tambm poderia ter escolhido rearranjar as colunas da tabela verdade a fim de deixar a sada
dependente de e ). A Figura 2.62 ilustra o novo projeto.
113
2.8.3. Decodificadores
Um decodificador possui entradas e 2 sadas. Ele ativa exatamente uma de suas sadas,
dependendo da combinao das entradas. A Figura 2.63 ilustra um decodificador 2:4. Quando 1:0 =
00, 0 = 1. Quando 1:0 = 01, 1 = 1, e assim por diante.
Exemplo 2.14 IMPLEMENTAO DE UM DECODIFICADOR

Implemente um decodificador 2:4 com portas AND, OR e NOT.
Soluo: A Figura 2.64 ilustra a implementao de um decodificador 2:4 utilizando quatro portas AND.
Cada porta depende de ambas as formas, verdadeiras e complementadas, de cada entrada. Em geral,
Figura 2.62 Novo circuito da Alyssa
um decodificador : 2 pode ser construdo a partir de 2 portas AND de entradas que aceitam as
vrias combinaes das entradas normais e complementadas. Cada sada num decodificador representa
um nico mintermo. Por exemplo, 0 representa o mintermo
1
0 . Esse fato ser conveniente quando
utilizarmos decodificadores em outros blocos digitais.
Lgica do Decodificador
Decodificadores podem ser combinados com portas OR para construrem funes lgicas. A Figura
2.65 mostra a funo XNOR de duas entradas utilizando um decodificador 2:4 e uma nica porta OR.
Devido a cada entrada do decodificador representar um nico mintermo, a funo construda como
OR de todos os mintermos na funo. Na Figura 2.65, = + =
.
Quando so utilizados decodificadores para se construir lgica, mais fcil expressar as funes na
forma de tabela verdade ou na forma cannica de soma de produtos. Uma funo de entradas com
1s na tabela verdade pode ser construda com um decodificador : 2 e um OR de entradas
Figura 2.63 Decodificador 2:4 conectadas a todos os mintermos contendo 1 na tabela verdade. Esse conceito ser aplicado para a
construo de Memrias de Apenas Leitura (Read Only Memories, ROMs), na Seo 5.5.6.
114
2.9. TEMPORIZAO
Nas sees anteriores, a nossa preocupao principal se o circuito funciona idealmente,
utilizando poucas portas. No entanto, como qualquer projetista amadurecido de circuitos ir constatar,
um dos problemas mais desafiadores no projeto de circuitos a temporizao: fazer um circuito
funcionar rapidamente.
Uma sada leva tempo para mudar a sua resposta a uma mudana na entrada. A Figura 2.66 mostra
o atraso entre a mudana na entrada e a mudana subsequente na sada de um buffer. A figura
chamada de diagrama de temporizao; ele representa a resposta transitria do circuito do buffer
quando a entrada muda. A transio do nvel LOW para HIGH chamada flanco ascendente.
Similarmente, a transio de HIGH para LOW (no mostrada na figura) chamada de flanco
descendente. A seta azul indica que o flanco ascendente de causada pelo flanco ascendente de .
Medimos o atraso do ponto de 50% do sinal de entrada, , at ao ponto de 50% do sinal de sada, . Figura 2.64 Implementao de um
O ponto de 50% o ponto em que o sinal est na metade do caminho (50%) entre os valores LOW e decodificador 2:4
HIGH conforme a transio realizada.
2.9.1. Atraso de Propagao e de Contaminao
A lgica combinatria caracterizada por seu atraso de propagao e contamination delay. O atraso
de propagao o tempo mximo a partir do qual a entrada muda de valor, at quando a sada ou
as sadas atingem seu valor final. O contamination delay o tempo mnimo a partir do qual a
entrada muda de nvel, at quando qualquer uma das sadas comece a mudar de valor.
A Figura 2.67 ilustra o atraso de propagao e contamination delay de um buffer em azul e cinza,
respectivamente. A figura mostra que inicialmente HIGH ou LOW e muda de estado num dado
instante; estamos interessados apenas no fato de que ele muda, mas no qual o valor que ele tem. Em
resposta, muda algum tempo depois. Os arcos indicam que comea a mudar de valor aps a
Figura 2.65 Funo lgica utilizando
transio de , e que definitivamente se estabelece no novo valor dentro do tempo . decodificador
115
As causas fundamentais para o atraso nos circuitos incluem o tempo necessrio para carregar as
capacitncias num circuito, e a velocidade da luz. e podem ser diferentes devido a muitas
Quando os projetistas falam sobre razoes, incluindo:
calcular o atraso de um circuito, eles
geralmente se referem ao pior caso (o Diferentes atrasos de subida e descida;
atraso de propagao), a no ser que Mltiplas entradas e sadas, algumas das quais so mais rpidas que outras;
esteja claro de uma outra forma, a partir Circuitos diminuem a velocidade quando esto quentes e aumentam quando esto frios.
do contexto.
Calcular e requer uma profundidade em nveis baixos de abstrao fora do escopo deste
livro. No entanto, os fabricantes normalmente fornecem data sheets especificando estes atrasos
para cada porta.
Juntamente com os fatores j listados, os atrasos de propagao e contamination delay so
tambm determinados atravs do caminho que um sinal faz da entrada para a sada. A Figura 2.68
mostra um circuito lgico de quatro entradas. O caminho crtico, mostrado a azul, o caminho da
entrada para a sada . o caminho mais longo e, portanto, o mais lento, pois a entrada viaja
atravs de trs portas at a sada. Esse caminho crtico pois limita a velocidade a que o circuito
opera. O caminho curto atravs do circuito, mostrado em cinza, vai da entrada D sada Y. Este o
menor, e portanto, mais rpido, caminho atravs do circuito, pois a entrada viaja atravs de apenas
uma porta para a sada.
Figura 2.66 Atraso do circuito
O atraso de propagao de um circuito combinatrio igual soma dos atrasos de propagao
atravs de cada elemento no caminho crtico. O contamination delay a soma dos contamination
delays atravs de cada elemento no caminho curto. Esses atrasos so mostrados na Figura 2.69 e so
descritos pelas seguintes equaes:
= 2 + (2.8)
= (2.9)
116
Atrasos nos circuitos so normalmente da

ordem de picossegundos (1 =
1012segundos) a nanossegundos
9
(1 = 10 segundos). Trilhes de
picossegundos foram gastos para o leitor
ler esta caixa de texto.
Figura 2.67 Atraso de propagao e de contaminao
Exemplo 2.15 ENCONTRANDO ATRASOS

Ben Bitdiddle precisa encontrar o atraso de propagao e o contamination delay do circuito mostrado
na Figura 2.70. De acordo com o seu datasheet, cada porta tem um atraso de propagao de 100 pico-
segundos (ps) e um contamination delay de 60 ps.
Figura 2.68 Caminho curto e caminho

crtico
117
Embora estejamos ignorando atraso de

condutor nesta anlise, os circuitos digitais so
agora to rpidos que o atraso de condutores
longos pode ser to importante quanto o
atraso das portas. A velocidade de atraso luz
em fios coberto no Apndice A.
Figura 2.70 Circuito do Ben
Figura 2.69 Formas de onda do caminho curto e do caminho crtico
Soluo: Ben comeou encontrando o caminho crtico e o caminho mais curto atravs do circuito.
O caminho crtico, destacado em azul na Figura 2.71, vai da entrada ou , atravs de trs portas,
at sada . Consequentemente, igual a trs vezes o atraso de propagao de uma nica
porta, ou 300 ps.
O caminho mais curto, mostrado em cinza na Figura 2.72, vai da entrada , ou atravs de
Figura 2.71 Caminho crtico do circuito do
Ben duas portas, para a sada . Existem apenas duas portas no caminho mais curto, ento igual
a 120 ps.
Exemplo 2.16 TEMPORIZAO DE MULTIPLEXADORES: CONTROLE CRTICO VS DADOS CRTICOS

Compare o pior caso de temporizao dos projetos de trs multiplexadores de quatro entradas
mostrados na Figura 2.58, na Seo 2.8.1. A Tabela 2.7 lista os atrasos de propagao dos
componentes. Qual o caminho crtico para cada projeto? Dada a sua anlise de temporizao,
porque o leitor escolheria um projeto ao invs de outro?
118
Soluo: Um dos caminhos crticos para cada uma das trs opes de projeto destacado em azul na
Figura 2.73 e Figura 2.74. indica o atraso de propagao da entrada para a sada ; indica
o atraso de propagao da entrada para a sada ; o pior dos dois: max( , ).
Tanto para a implementao lgica de dois nveis quanto para a implementao por tristates na
Figura 2.73, o caminho crtico vai de um dos sinais de controle para a sada : = . Estes
circuitos so de controle crtico, devido ao caminho crtico ir dos sinais de controle sada. Qualquer Figura 2.72 Caminho mais curto do
atraso adicional nos sinais de controle vai diretamente para o pior caso de atraso. O atraso de para circuito do Ben
na Figura 2.73 (b) de apenas 50 ps, comparado ao atraso de para , de 125 ps.
A Figura 2.74 mostra a implementao hierrquica de um multiplexador 4:1 utilizando dois estgios
de multiplexadores 2:1. O caminho crtico vai de qualquer uma das entradas para a sada. Este
circuito crtico em dados, pois o caminho crtico vai da entrada de dados at a sada: = .
Se as entradas de dados chegam bem antes das entradas de controle, poderamos preferir o
projeto com o menor atraso controle-sada (o projeto hierrquico da Figura 2.74). Similarmente, se
as entradas de controle chegam bem antes das entradas de dados, ns poderamos preferir o projeto
com o menor atraso dados-sada (o projeto com tristates da Figura 2.73 (b)).
A melhor escolha depende no apenas do caminho crtico atravs do circuito e dos tempos de
chegada, mas tambm da potncia, custo e disponibilidade de componentes.
119
Figura 2.73 Atrasos de propagao num multiplexador 4:1: (a) lgica de dois nveis; (b) tristate
Tabela 2.7 Especificaes de temporizao para elementos de circuitos multiplexadores
Figura 2.74 Atraso de propagao em

um multiplexador: Hierrquico
utilizando multiplexadores 2:1
120
2.9.2. Glitches
At agora temos discutido o caso em que uma nica mudana na entrada causa uma nica mudana
na sada. No entanto, possvel que uma nica transio na entrada cause mltiplas transies na
sada. Elas so chamadas de glitches ou hazards. Apesar de os glitches normalmente no causarem
problemas, importante perceber que eles existem, e reconhece-los ao olhar um diagrama de
temporizao. A Figura 2.75 mostra um circuito com um glitche e o mapa de Karnaugh do circuito.
A equao Booleana corretamente minimizada, mas vamos dar uma olhada no que acontece
quando = 0, = 1 e transita de 1 para 0. A Figura 2.76 ilustra este cenrio. O caminho mais curto
(caminho em cinza) passa atravs de duas portas, a AND e a OR. O caminho crtico (mostrado em azul)
passa atravs da inversora e de duas portas, a AND e a OR.
Com a transio de de 1 para 0, n2 (no caminho mais curto) cai antes que n1 (no caminho crtico)
possa se elevar. At que n1 aumente, as duas entradas da porta OR so 0, e a sada cai para 0. Figura 2.75 Circuito com Glitch
Quando n1 eventualmente aumenta, retorna a 1. Como mostrado no diagrama de temporizao
da Figura 2.76, inicia em 1 e termina em 1, mas momentaneamente vai para o valor 0.
Enquanto esperarmos que atraso de propagao termine antes que dependamos da sada, os
glitches no sero um problema, pois a sada eventualmente vai para o valor correto.
Caso optemos por isso, podemos evitar o glitch adicionando outra porta lgica na implementao.
Isso mais simples de se entender em termos do K-map. A Figura 2.77 mostra como uma mudana na
entrada em de = 001 para = 011 se move de um implicante principal para outro. A
mudana atravs da fronteira dos dois implicantes principais no mapa de Karnaugh indicam um
possvel glitch.
Como vimos no diagrama de temporizao na Figura 2.76, se a implementao do circuito de um
dos implicantes primos desliga antes que o circuito de outro implicante primo possa ligar, existe um
glitch. Para consertar isto, adicionamos outro crculo que cobre a fronteira do implicante primo, como
mostrado na Figura 2.78. O leitor talvez possa reconhecer isso como teorema do consenso, onde o
termo adicionado, , o consenso ou termo redundante.
121
A Figura 2.79 mostra o circuito prova de glitch. A porta AND adicionada destacada em azul.
Agora, a mudana de quando = 0 e = 1 no causa um glitch na sada, pois a porta AND azul
emite 1 durante toda a transio.
Figura 2.77 Mudana na entrada

cruzando a fronteira do implicante
Figura 2.76 Temporizao de um glitch
Em geral, um glicth pode ocorrer quando uma mudana numa varivel atravessa a fronteira entre
dois implicantes primos num mapa de Karnaugh. Podemos eliminar o glitch adicionando implicantes
Figura 2.78 K-map sem o glitch redundantes ao K-map para cobrir essas fronteiras. Isso, claro, vem com um custo extra de
hardware.
No entanto, mudanas simultneas em vrias entradas tambm podem causar glitches. Este tipo
de glitches no pode ser resolvido adicionando-se hardware. Devido vasta maioria de circuitos de
sistemas de interesse que possuem transies simultneas (ou quase simultneas), os glitches so
um fato na vida da maioria dos circuitos. Apesar de termos mostrado como eliminar um tipo de
glitch, o ponto de discusso no sobre elimin-los, mas estar cientes de que eles existem. Isso
Figura 2.79 Circuito sem o glitch especialmente importante quando analisamos os diagramas de temporizao num simulador ou
osciloscpio.
122
2.10. SUMRIO
Um circuito digital um mdulo com entradas e sadas de valores discretos e uma especificao
descrevendo a funo e a temporizao do mdulo. Este Captulo teve o seu foco nos circuitos
combinatrios, nos quais as sadas dependem unicamente dos valores atuais de entradas.
A funo de um circuito combinatrio pode ser dada por uma tabela verdade ou equao
Booleana. A equao Booleana para qualquer tabela verdade pode ser obtida sistematicamente
utilizando-se a forma de soma de produtos ou de produto de somas. Na forma de soma de produtos,
a funo escrita como a soma (OR) de um ou mais implicantes. Implicantes so produtos (AND) de
literais. Literais so as formas verdadeiras ou complementadas das variveis de entrada.
As equaes Booleanas podem ser simplificadas utilizando-se as regras da lgebra Booleana. Em
particular, elas podem ser simplificadas em mnimas formas de soma de produtos atravs da
combinao de implicantes que diferem entre si apenas na forma verdadeira e complementada de
um dos literais: + = . Os mapas de Karnaugh so ferramentas visuais de minimizao de
funes de at quatro variveis. Na prtica, os projetistas podem usualmente simplificar funes de
poucas variveis por inspeo. Ferramentas de projeto auxiliado por computador so utilizadas para
funes mais complicadas; tais mtodos e ferramentas so discutidos no Captulo 4.
As portas lgicas so conectadas entre si para criar circuitos combinatrios que realizam uma
funo desejada. Qualquer funo na forma de soma de produtos pode ser construda utilizando-se
lgica de dois nveis: os complementos das entradas so constitudos por portas NOT, os produtos
por portas AND, e as somas, por portas OR. Dependendo da funo e dos blocos lgicos disponveis,
implementaes lgicas multi-nvel com vrios tipos de portas podem ser mais eficientes. Por
exemplo, os circuitos CMOS favorecem portas NAND e NOR, pois essas portas podem ser construdas
diretamente por transistores CMOS sem que portas NOT extra sejam necessrias. Quando portas
NAND e NOR so utilizadas, a tcnica dos empurres de bolha til para acompanhar as inverses.
123
As portas lgicas so combinadas para produzir circuitos maiores, como multiplexadores,

decodificadores, e circuitos de prioridade. Um multiplexador escolhe uma das entradas de dados
baseado numa entrada de seleo. Um decodificador leva uma das sadas para nvel HIGH de acordo
com as entradas. Um circuito de prioridade produz uma sada indicando qual a entrada de maior
prioridade. Todos esses circuitos so exemplos de blocos combinatrios. O Captulo 5 ir introduzir
mais blocos lgicos, incluindo outros circuitos aritmticos. Esses blocos sero utilizados
extensivamente para construir um microprocessador no Captulo 7.
A especificao de temporizao de um circuito combinatrio consiste nos atrasos de propagao
e contaminao do circuito. Estes indicam os maiores e menores tempos entre uma mudana na
entrada e a consequente mudana na sada. Calcular o atraso de propagao de um circuito envolve
identificar o caminho crtico atravs do circuito e, ento, adicionar os atrasos de propagao para
cada elemento ao longo do caminho. Existem muitas maneiras diferentes de se implementar circuitos
combinatrios complicados; essas maneiras oferecem compensaes entre velocidade e custo.
O prximo Captulo ir se deslocar para os circuitos sequenciais, nos quais as sadas dependem
tanto dos valores atuais como os valores anteriores das entradas. Por outras palavras, circuitos
sequenciais possuem memria do passado.
124
Exerccios
Exerccio 2.1 Escreva a equao Booleana na forma cannica de soma de produtos para cada uma
das tabelas verdade na Figura 2.80.
Figura 2.80 Tabelas verdade para os Exerccio 2.1 e Exerccio 2.3
Exerccio 2.2 Escreva a equao Booleana na forma cannica de soma de produtos para cada uma
das tabelas verdade na Figura 2.81.
125
Figura 2.81 Tabelas verdade para os Exerccio 2.2 e Exerccio 2.4
Exerccio 2.3 Escreva a equao Booleana na forma cannica de produto das somas para cada
uma das tabelas verdade na Figura 2.80.
Exerccio 2.4 Escreva a equao Booleana na forma cannica de produto das somas para cada
uma das tabelas verdade na Figura 2.81.
Exerccio 2.5 Minimize cada uma das equaes Booleanas do Exerccio 2.1.
Exerccio 2.6 Minimize cada uma das equaes Booleanas do Exerccio 2.2.
126
Exerccio 2.7 Esboce um circuito combinatrio razoavelmente simples implementando cada uma
das funes do Exerccio 2.5. Razoavelmente simples significa que o leitor no vai desperdiar
portas lgicas, mas tampouco vai gastar muito tempo verificando cada possvel implementao
para o circuito.
Exerccio 2.8 Esboce um circuito combinatrio razoavelmente simples implementando cada uma
das funes do Exerccio 2.6.
Exerccio 2.9 Repita o Exerccio 2.7 usando apenas portas NOT, AND e OR.
Exerccio 2.10 Repita o Exerccio 2.8 usando apenas portas NOT, AND e OR.
Exerccio 2.11 Repita o Exerccio 2.7 usando apenas portas NOT, N AND e NOR.
Exerccio 2.12 Repita o Exerccio 2.8 usando apenas portas NOT, NAND e NOR.
Exerccio 2.13 Simplifique as seguintes equaes Booleanas utilizando os teoremas Booleanos.

Verifique se as respostas esto corretas utilizando uma tabela verdade ou um K-map.
(a) = +
(b) = + + (
+ )
(c) =
+ + + +
+ +
127
Exerccio 2.14 Simplifique as seguintes equaes Booleanas utilizando os teoremas Booleanos.

Verifique se as respostas esto corretas utilizando uma tabela verdade ou um K-map.
(a) = +
(b) +
=
(c) = + (
+
+ + + )
Exerccio 2.15 Esboce um circuito combinatrio relativamente simples implementando cada uma
Exerccio 2.16 Esboce um circuito combinatrio relativamente simples implementando cada uma
Exerccio 2.17 Simplifique cada uma das seguintes equaes Booleanas. Esboce um circuito
combinatrio relativamente simples implementando a equao simplificada.
(a) = + +
(b) =
+ + +
+
(c)
= + + + + + ( + + ) + + +
+

Exerccio 2.18 Simplifique cada uma das seguintes equaes Booleanas. Esboce um circuito
combinatrio relativamente simples implementando a equao simplificada.
(a) = +
+
(b)
= ( + + ) + +
(c)
= + + ( + )
128
Exerccio 2.19 D um exemplo de uma tabela verdade que requer entre 3 e 5 bilhes de linhas e
pode ser construda utilizando-se menos de 40 (mas pelo menos 1) portas de duas entradas.
Exerccio 2.20 D um exemplo de um circuito com um caminho cclico e que mesmo assim
combinatrio.
Exerccio 2.21 Alyssa P. Hacker diz que qualquer funo Booleana pode ser escrita na forma mnima
de soma de produtos como uma soma de todos os implicantes primos da funo. Ben Bitdiddle diz
que existem algumas funes para as quais as suas equaes mnimas no envolvem todos os
implicantes primos. Explique por que Alyssa est certa ou d um contra-exemplo demostrando o
ponto de Ben.
Exerccio 2.22 Prove que os teoremas a seguir so verdadeiros utilizando induo perfeita. O leitor
no precisar provar seus duais.
(a) O teorema da idempotncia (T3)
(b) O teorema da distributividade (T8)
(c) O teorema da cominao (T10)
Exerccio 2.23 Prove o Teorema de De Morgan (T12) para trs variveis, 1, 2, 0, utilizando
induo perfeita.
Exerccio 2.24 Escreva equaes Booleanas para o circuito da Figura 2.82. O leitor no precisar
minimizar as equaes.
129
Figura 2.82 Esquemtico do circuito
Exerccio 2.25 Minimize as equaes Booleanas do Exerccio 2.24 e esboce um circuito melhorado
com a mesma funo.
Exerccio 2.26 Utilizando portas equivalentes de De Morgan e mtodos de empurro de bolha,

redesenhe o circuito da Figura 2.83 a fim de que o leitor possa encontrar a equao Booleana por
inspeo. Escreva a equao Booleana.
Figura 2.83 Circuito esquemtico
130
Exerccio 2.27 Repita o Exerccio 2.26 para o circuito da Figura 2.84.
Figura 2.84 Circuito esquemtico
Exerccio 2.28 Encontre a equao Booleana mnima para a funo na Figura 2.85. Lembre-se de
tirar vantagem das entradas dont care.
Figura 2.85 Tabela verdade do exerccio 2.28
Exerccio 2.29 Esboce um circuito para a funo do Exerccio 2.28.
131
Exerccio 2.30 O seu circuito feito no Exerccio 2.29 tem algum glitch potencial quando uma das
entradas varia? Se no, explique porque no. Se sim, mostre como modificar o circuito para eliminar
os glitches.
Exerccio 2.31 Encontre a equao Booleana mnima para a funo na Figura 2.86. Lembre-se de
tirar vantagem das entradas dont care.
Figura 2.86 Tabela verdade do exerccio 2.31
Exerccio 2.32 Esboce um circuito para a funo lgica do Exerccio 2.31.
Exerccio 2.33 Ben Bitdiddle vai aproveitar seu piquenique em dias ensolarados e sem formigas. Ele
tambm vai aproveitar o seu piquenique em qualquer dia que haja um beija flor, assim como em dias
que existam formigas e joaninhas. Escreva uma equao Booleana para seu aproveitamento (A) em
termos do Sol (S), das formigas (F), dos beija flores (B) e das joaninhas (J).
132
Exerccio 2.34 Complete o projeto do decodificador de sete segmentos atravs de (ver

Exerccio 2.10):
(a) Derive equaes Booleanas para as sadas atravs de , assumindo que entradas maiores
do que 9 produzem entradas em branco (0).
(b) Derive equaes Booleanas para as sadas atravs de , assumindo que entradas maiores
do que 9 so consideradas dont cares.
(c) Esboce um a implementao a nvel de portas lgicas relativamente simples do item (b). Sadas
mltiplas podem ser compartilhadas quando apropriado.
Exerccio 2.35 Um circuito possui quatro entradas e duas sadas. As entradas 3:0 representa um
nmero de 0 a 15. A sada deve ser TRUE se o nmero for primo (0 e 1 no so primos, mas 2,3,5 e
assim por diante, so). A sada deve ser TRUE se o nmero for divisvel por 3. D equaes Booleanas
simplificadas para cada sada e esboce o circuito.
Exerccio 2.36 Um codificador de prioridades possui 2 entradas. Ele produz uma sada binria de
N-bits indicando se o bit mais significativo da entrada TRUE, ou 0 se nenhuma das entradas for TRUE.
Ele tambm produz uma sada NONE, que TRUE se nenhuma das entradas TRUE. Projete um
codificador de prioridade de oito entradas com entradas 7:0 e sadas 2:0 e NONE. Por exemplo, se as
entradas so 00100000, a sada deve ser 101 e NONE deve ser 0. Fornea a equao Booleana
simplificada para cada sada, e esboce o esquemtico.
Exerccio 2.37 Projete um codificador de prioridades modificado (veja o Exerccio 2.36) que recebe
uma entrada de 8 bits e produz duas sadas de 3 bits, 2:0 e 2:0. indica que o bit mais significativo
da entrada TRUE. indica que o segundo bit mais significativo da entrada TRUE. deve ser 0 se
nenhuma das entradas TRUE. deve ser 0 no mais que uma das entradas VERDADEIRO. D a
equao Booleana simplificada para cada sada e esboce o esquemtico.
133
Exerccio 2.38 Um cdigo de termmetro de M bits para o nmero k consiste de k bits 1 nas
posies menos significativas e M k bits 0 em todos outros bits significativos. Um cdigo conversor
de binrio para termmetro tem N entradas e 21 sadas. Ele produz um cdigo de termmetro de
21 bits para o nmero especificado na entrada. Por exemplo, se as entradas so 110, a sada deve
ser 0111111. Projete um conversor de cdigo binrio para termmetro 3:7. D a equao Booleana
simplificada para cada sada, e esboce o esquemtico.
Exerccio 2.39 Escreva a equao Booleana minimizada para a funo realizada pelo circuito na
Figura 2.87.
Figura 2.87 Circuito multiplexador
Exerccio 2.40 Escreva a equao Booleana minimizada para a funo realizada pelo circuito na
Figura 2.88.
Figura 2.88 Circuito multiplexador
Exerccio 2.41 Implemente a funo da Figura 2.80 (b) utilizando:

(a) Um multiplexador 8:1
134
(b) Um multiplexador 4:1 e uma inversora

(c) Um multiplexador 2:1 e duas outras portas lgicas
Exerccio 2.42 Implemente a funo do Exerccio 2.17 (a) utilizando:
Um multiplexador 8:1
Um multiplexador 4:1 e uma inversora
Um multiplexador 2:1 e duas outras portas lgicas
Exerccio 2.43 Determine o atraso de propagao e o atraso de contaminao do circuito na

Figura 2.83. Use os atrasos de porta dados na Tabela 2.8.
Exerccio 2.44 Determine o atraso de propagao e o atraso de contaminao do circuito na

Figura 2.84. Use os atrasos de porta dados na Tabela 2.8.
Tabela 2.8 Atrasos de porta para os Exerccio 2.43 Exerccio 2.47
135
Exerccio 2.45 Esboce o esquemtico para um decodificador rpido 3:8. Suponha que os atrasos
de porta so dados pela Tabela 2.8 (e apenas as portas daquela tabela esto disponveis). Projete
seu decodificador para que ele tenha o menor caminho crtico possvel, e indique qual caminho
esse. Quais so os atrasos de propagao e de contaminao?
Exerccio 2.46 Projete novamente o circuito do Exerccio 2.35 para que ele seja o mais rpido
possvel. Utiliza apenas as portas da Tabela 2.8. Esboce o novo circuito e indique qual o caminho
crtico. Quais so os atrasos de propagao e de contamination?
Exerccio 2.47 Projete novamente o circuito do Exerccio 2.36 para que ele seja o mais rpido
possvel. Utiliza apenas as portas da Tabela 2.8. Esboce o novo circuito e indique qual o caminho
crtico. Quais so os atrasos de propagao e de contamination?
Exerccio 2.48 Projete um multiplexador 8:1 com o menor atraso possvel das entradas de dados
para a sada. O leitor pode utilizar qualquer uma das portas da Tabela 2.7. Esboce o esquemtico.
Utilizando os atrasos de porta dados pela tabela, determine o atraso total.
136
Essas perguntas foram feitas em entrevistas para trabalhos de projeto digital.
Pergunta 2.1 Esboce um esquema para a funo XOR de duas entradas usando apenas portas
NAND. Apenas quantos pode usar?
Pergunta 2.2 Projete um circuito que vai dizer se um determinado ms tem 31 dias. O ms
especificado por uma entrada de 4-bits A3:0. Por exemplo, se as entradas so 0001, o ms janeiro, e
se as entradas so 1100, o ms dezembro. A sada Y circuito deve ser ativada apenas quando o ms
especificado pelas entradas tem 31 dias nele. Escreva a equao simplificada, e desenhe o diagrama
de circuito utilizando um nmero mnimo de portas. (Dica: Lembre-se de tirar proveito das condies
dont care.)
Pergunta 2.3 O que um buffer tristate? Como e porque usado?
Pergunta 2.4 Uma porta ou conjunto de portas universal, se pode ser usado para construir
qualquer funo Booleana. Por exemplo, o conjunto {AND, OR, NOT} universal.
(a) Uma porta AND, por si s universal? Porque o ou porque o no ?
(b) o conjunto {OR, NOT} universal? Porque o ou porque o no ?
(c) a porta NAND por si s universal? Porque o ou porque o no ?
137
138
3. Projeto de Lgica Digital
3.1. INTRODUO
No ltimo Captulo, demonstramos como analisar e projetar lgica combinatria. A sada da lgica
combinatria depende apenas dos valores atuais das entradas. Dada uma especificao sob a forma
de tabela verdade ou equao booleana, podemos criar um circuito otimizado que observa as
especificaes.
Neste Captulo, vamos analisar e projetar lgica sequencial. As sadas da lgica sequencial
dependem tanto dos atuais valores da entrada como dos anteriores. Assim, a lgica sequencial tem
memria. A lgica sequencial pode lembrar-se explicitamente de certas entradas anteriores, ou pode
refinar as entradas anteriores numa quantidade menor de informao chamada de estado do
sistema. O estado de um circuito sequencial digital definido por um conjunto de bits designado de
variveis de estado que contm todas as informaes sobre o passado necessrias para explicar o
comportamento futuro do circuito.
O Captulo comea por estudar bsculas e flip-flops, que so circuitos sequenciais simples que
armazenam o estado de um bit. Em geral, os circuitos sequenciais possuem uma anlise complexa.
Para simplificar o projeto, vamos disciplinarmo-nos a construir apenas circuitos sequenciais
sncronos formados por lgica combinatria e bancos de flip-flops que contm o estado do circuito.
O Captulo descreve mquinas de estados finitos, que so uma maneira fcil de projetar circuitos
sequenciais. Finalmente, analisamos a velocidade dos circuitos sequenciais e discutimos o
paralelismo como uma forma de aumentar a velocidade.
139
Captulo trs Projeto de Lgica Digital
3.2. BSCULAS E FLIP-FLOPS

O bloco de construo fundamental de memria um elemento biestvel, um elemento com dois estados
estveis. A Figura 3.1 (a) mostra um elemento biestvel simples consistindo de um par de inversores ligados
em realimentao. A Figura 3.1 (b) mostra o mesmo circuito redesenhado para enfatizar a simetria. Os
inversores esto numa configurao cross-coupled, o que significa que a entrada de I1 a sada de I2 e vice-
.
versa. O circuito no tem entradas, mas possui duas sadas, Q e Q
Figura 3.1 Par de inversores cross-coupled

Da mesma forma que Y A anlise deste circuito diferente da anlise de um circuito combinatria porque cclica: Q depende de
vulgarmente usado para a sada da , e depende Q. Considere os dois casos, Q 0 ou Q 1. Trabalhando com as consequncias de cada caso,

lgica combinatria, Q
temos:
comumente utilizada para a sada
da lgica sequencial. Caso I: Q = 0
Como mostrado na Figura 3.2 (a), I2 recebe uma entrada FALSE, Q, de modo que produz uma
sada de TRUE em : I1 recebe uma entrada TRUE, , de modo que produz uma sada FALSE
em Q. Isto consistente com a suposio inicial que Q = 0, de modo que este caso estvel.
Caso II: Q = 1
Como mostrado na Figura 3.2 (b), I2 recebe uma entrada TRUE e produz uma sada FALSE em
: I1 recebe uma entrada FALSE e produz uma sada TRUE em Q. Este caso novamente
estvel.
140
Figura 3.2 Operao biestvel de um par de inversores cross-coupled
Dado que os inversores cross-coupled tm dois estados estveis, Q = 0 e Q = 1, o circuito dito biestvel.
Um ponto subtil que o circuito tem um terceiro estado possvel com ambas as sadas aproximadamente a
meio caminho entre 0 e 1. Isso designado por estado metaestvel e ser discutido na Seo 3.5.4.
Um elemento com N estados estveis transmite log2N bits de informao, de modo que um elemento
biestvel armazena 1 bit. O estado dos inversores cross-coupled est contido numa varivel de estado
binrio, Q. O valor de Q diz-nos tudo sobre o passado que necessrio para explicar o comportamento
futuro do circuito. Especificamente, se Q = 0, ele permanecer para sempre a 0, e se Q = 1, ele permanecer
a 1 para sempre. O circuito tem um outro n, , mas no contm qualquer informao adicional porque
se Q conhecido, tambm conhecido. Por outro lado, tambm uma opo aceitvel para a varivel
de estado.
Quando a energia aplicada pela primeira vez a um circuito sequencial, o estado inicial desconhecido
e geralmente imprevisvel. Ele pode ser diferente de cada vez que o circuito seja ligado.
Embora os inversores cross-coupled possam armazenar 1 bit de informao, eles no so prticos porque o
utilizador no tem entradas para controlar o estado. No entanto, outros elementos biestveis, tais como
bsculas e flip-flops, disponibilizam entradas para controlar o valor da varivel de estado. O restante desta
seco considera estes circuitos.
3.2.1. Bscula SR
Um dos circuitos sequenciais mais simples a bscula SR, a qual composta por duas portas NOR na
configurao cross-coupled, tal como mostrado na Figura 3.3. A bsculas tem duas entradas, S e R, e duas
sadas, Q e : A bscula SR semelhante ao inversor cross-couple, mas o seu estado pode ser controlado
atravs das entradas S e R, que fazem set e reset da sada Q.
141
Figura 3.3 Esquema de uma bscula RS
Uma boa maneira de entender um circuito desconhecido analisar a sua tabela verdade, de modo que
por onde vamos comear. Lembre-se que uma porta NOR produz uma sada FALSE quando uma entrada
for TRUE. Considere as quatro possveis combinaes de R e S.
Caso I: R = 1, S = 0
N1 v finalmente uma entrada TRUE, R, de modo que produz uma sada FALSE em Q. N2 v ambos Q e S
FALSE, por isso produz uma sada TRUE em :
Caso I: II: R = 0, S = 1
N1 recebe entradas de 0 e : Porque ns ainda no sabemos , no podemos determinar a sada Q. N2

recebe finalmente uma entrada TRUE, S, por isso produz uma sada FALSE em : Agora podemos revisitar
N1, sabendo que ambas as entradas so FALSE, ento a sada Q TRUE.
Caso III: R = 1, S = 1
N1 e N2 veem finalmente uma entrada TRUE (R ou S), de modo que cada uma produz uma sada FALSE. Da
Q e serem ambas FALSE.
Caso IV: R = 0, S = 0
N1 recebe a entradas de 0 e : Porque ns ainda no sabemos , no podemos determinar a sada. N2

recebe entradas de 0 e Q. Porque ns ainda no sabemos Q, no podemos determinar a sada. Agora
estamos presos. Esta uma reminiscncia dos inversores cross-coupled. Mas sabemos que Q deve ser 0 ou
1. Assim, podemos resolver o problema, verificando o que acontece em cada uma destes subcasos.
142
Caso IVa: Q = 0
Dado que S e Q so FALSE, N2 produz uma sada TRUE em Q , como mostrado na Figura 3.4 (a). Agora
N1 recebe uma entrada TRUE, Q , ento a sua sada, Q, FALSE, da mesma forma que tnhamos
assumido.
Caso IVb: Q = 1
Uma vez que Q TRUE, N2 produz uma sada FALSE em , como mostrado na Figura 3.4 (b). Agora
N1 recebe duas entradas FALSE, R e , logo sua sada, Q, TRUE, da mesma forma que tnhamos
assumido.
Figura 3.4 Estados biestveis de uma bscula SR
Colocando tudo junto, suponha que Q tem algum valor antes conhecido, a que chamaremos Qprev, antes
de entrarmos no caso IV. Qprev 0 ou 1, e representa o estado do sistema. Quando R e S so 0, Q vai-se lembrar
deste antigo valor, Qprev, e ser o seu complemento, . Este circuito tem memria.
A tabela verdade da Figura 3.5 resume esses quatro casos. As entradas S e R significam Set e Reset. Fazer
set de 1 bit significa torn-lo TRUE. Fazer reset de 1 bit significa torn-lo FALSE. As sadas, Q e , so
normalmente complementares. Quando R ativo, Q faz reset a 0 e faz o contrrio. Quando S ativo, Q
definido como 1 e faz o contrrio. Quando nenhuma entrada est ativa, Q lembra o seu antigo valor, Qprev.
Ativando S e R simultaneamente no faz muito sentido, porque isso significa que a bscula deve ser ligada e
desligada ao mesmo tempo, o que impossvel. O circuito responde levando ambas as sadas 0.
143
Figura 3.5 Tabela verdade de uma bscula SR
Figura 3.6 Smbolo de uma bscula SR
A bscula SR representada pelo smbolo na Figura 3.6. Usar o smbolo uma aplicao de abstrao e
modularidade. Existem vrias maneiras de construir uma bscula SR, tais como o uso de diferentes portas
lgicas e transstores. No entanto, qualquer elemento do circuito com o relacionamento especificado pela
tabela verdade na Figura 3.5 e o smbolo na Figura 3.6 chamado de bscula SR.
Como os inversores cross-coupled, a bscula SR um elemento biestvel, com 1 bit de estado
armazenado em Q. No entanto, o estado pode ser controlado atravs das entradas S e R. Quando R
ativado, o estado reposto a 0. Quando S ativado, o estado definido como 1. Quando nenhuma das
entradas ativada, o estado mantm o seu valor antigo. Observe que toda a histria das entradas pode ser
avaliada pela varivel nica de estado Q. No importa o padro de set ou reset ocorrido no passado, tudo
o que necessrio para prever o comportamento futuro da bscula SR se ela esteve mais recentemente
set ou reset.
3.2.2. Bscula D
A bscula SR perigosa porque ela tem um comportamento estranho quando ambas as entradas S e R
so ativadas simultaneamente. Alm disso, as entradas S e R confundem as questes de o qu e quando.
Ativando uma das entradas determina no apenas o que o estado deve ser, mas tambm quando se deve
mudar. Projetar circuitos torna-se mais fcil quando essas perguntas sobre o qu e quando esto separadas.
144
A bscula D na Figura 3.7 (a), resolve estes problemas. Ela tem duas entradas. A entrada de dados, D, controla
qual deve ser o prximo estado. A entrada de clock, CLK, controla quando o estado deve mudar.
Mais uma vez, analisamos a bscula escrevendo a tabela verdade, dada na Figura 3.7 (b). Por convenincia,
consideramos em primeiro lugar os ns internos , S e R. Se CLK = 0, S e R so FALSE, independentemente do
valor de D. Se CLK = 1, uma porta AND ir produzir TRUE e outra FALSE, dependendo do valor de D. Dado S e
R, Q e so determinados usando a Figura 3.5. Observe que quando CLK = 0, Q lembra o seu antigo valor,
Qprev. Quando CLK = 1, Q = D. Em todos os casos, o smbolo representa o complemento de Q, como lgico.
A bscula D evita o perigoso caso de simultaneamente ativar as entradas R e S.
Juntando tudo, vemos que o relgio controla quando os dados fluem atravs da bscula. Quando
CLK = 1, a bscula est transparente. Os dados em D fluem atravs de Q, como se a bscula fosse apenas um
buffer. Quando CLK = 0, a bscula est opaca. Ela bloqueia os novos dados de flurem para Q, e Q mantm o Algumas pessoas preferem usar
valor antigo. Assim, a bscula D s vezes chamada de bscula transparente ou uma bscula sensvel ao nvel. bscula aberta ou fechada em vez
O smbolo da bscula D fornecido na Figura 3.7 (c). de transparente ou opaca. No
entanto, achamos que esses
A bscula D atualiza o seu estado continuamente enquanto CLK = 1. Veremos mais tarde neste Captulo que termos so ambguos - aberto
til atualizar o estado somente num instante especfico no tempo. O flip-flop D descrito na prxima seo significa transparente, como uma
faz exatamente isso. porta aberta, ou opaco, como um
circuito aberto?
Figura 3.7 bscula D: (a) esquema, (b) tabela verdade, (c) smbolo
145
3.2.3. Flip-flop D
Um flip-flop D pode ser construdo a partir de duas bsculas D controladas por relgios
complementares, como se mostra na Figura 3.8 (a). A primeira bscula, L1, chamada de mestre. A
segunda bscula, L2, chamada de escravo. O n entre elas chamado de N1. Um smbolo para o flip-flop
D dado na Figura 3.8 (b). Quando a sada no necessria, o smbolo frequentemente condensado
como na Figura 3.8 (c).
Quando o CLK = 0, a bscula mestre est transparente e o escravo est opaco. Portanto, qualquer que
seja o valor em D propagado para N1. Quando CLK = 1, o mestre torna-se opaco e o escravo torna-se
transparente. O valor em N1 propagado para Q, mas N1 cortado de D. Assim, o valor que estava em D
A distino precisa entre flip-flops e imediatamente antes que o relgio efetuasse a transio de 0 para 1 copiado para Q imediatamente
bscula um pouco confusa e aps a subida do relgio. Em todas as outras vezes, Q mantm o seu valor antigo, porque h sempre uma
evoluiu ao longo do tempo. No uso
bscula opaca bloqueando o caminho entre D e Q.
comum da indstria, um flip-flop
disparado por borda. Em outras Por outras palavras, um flip-flop D cpia o nvel lgico de D para Q na borda ascendente do relgio, e
palavras, um elemento biestvel, relembra o seu estado em todas as outras vezes. Releia esta definio at que a tenha memorizado; um
com uma entrada de relgio. O dos problemas mais comuns para projetistas digitais iniciantes esquecer o que um flip-flop faz. A borda
estado das mudanas do flip-flop ascendente do relgio muitas vezes chamada abreviadamente de flanco do clock. A entrada D especifica
apenas em resposta a um relgio,
qual ser o novo estado. O clock indica quando o estado deve ser atualizado.
como quando o relgio sobe de 0 a
1. Um elemento biestvel sem um
relgio disparado por borda
comumente chamado de bsculas.
O termo flip-flop ou bscula por si

s geralmente refere-se a uma
bscula D ou flip-flop D,
respectivamente, porque estes so
os tipos mais comumente utilizados
na prtica.
Figura 3.8 Flip-flop D: (a) esquemtico, (b) smbolo, (c) smbolo condensado
146
Exemplo 3.1 CONTAGEM DE TRANSSTORES NUM FLIP-FLOP

Quantos transstores so necessrios para construir o flip-flop D descrito nesta seo?
Soluo: Uma porta NAND ou NOR usa quatro transstores. Uma porta NOT utiliza dois transstores. Uma
porta AND construda a partir de uma NAND e outra NOT, pelo que ela usa seis transstores. A bscula SR
usa duas portas NOR, ou seja, oito transstores. A bscula D usa uma bscula SR, duas portas AND, e uma
porta NOT, ou seja, 22 transstores. O flip-flop D usa duas bsculas D e uma porta NOT, ou seja, 46
transstores. A Seco 3.2.7 descreve uma implementao CMOS mais eficiente usando portas de
transmisso.
Um flip-flop D tambm conhecido como um flip-flop mestre-escravo, um flip-flop disparado por borda,
ou um flip-flop disparado por borda positiva. O tringulo nos smbolos denota uma entrada de relgio
disparado por borda. A sada muitas vezes omitida quando ela no necessria.
3.2.4. Registro
Figura 3.9 Registro de 4-bits:
Um registro de N-bits um banco de N flip-flops que compartilham uma entrada CLK comum, de modo
(a) esquemtico, (b) smbolo
que todos os bits do registro so atualizados em simultneo. Os registros so os alicerces fundamentais da
maioria dos circuitos sequenciais. A Figura 3.9 mostra o esquema e o smbolo para um registro de quatro
bits com entradas D3:0 e sadas Q3:0. D3:0 e Q3:0 so dois barramentos de 4-bits.
3.2.5. Enabled Flip-Flop
Um enabled flip-flop possui outra entrada chamada EN ou habilitar para determinar se os dados so
carregados na transio do relgio. Quando EN TRUE, o enabled flip-flop comporta-se como um flip-flop
D comum. Quando EN FALSE, o enabled flip-flop ignora o relgio e mantm o seu estado. Os enabled flip-
flops so teis quando se deseja carregar um novo valor para um flip-flop apenas em algumas das vezes,
em vez de a cada transio do relgio.
147
A Figura 3.10 mostra duas maneiras de construir um enabled flip-flop a partir de um flip-flop D e uma
porta extra. Na Figura 3.10 (a), um multiplexador de entrada escolhe se se deve passar o valor de D, se EN
TRUE, ou para reciclar o velho estado de Q, se EN FALSE. Na Figura 3.10 (b), o relgio passa por uma
porta lgica. Se EN TRUE, a entrada CLK para o flip-flop comuta normalmente. Se EN FALSE, a entrada
CLK tambm FALSE e o flip-flop mantm o seu valor antigo. Observe que EN no deve mudar enquanto
CLK = 1, para que o flip-flop veja um glitch no relgio (comutao num momento incorreto). Geralmente,
executar lgica no relgio uma m ideia. Fazer passar o relgio por uma porta atrasa o relgio e pode
causar erros temporais, como veremos na Seo 3.5.3, assim devemos faz-lo apenas se houver a certeza
de que se sabe o que se est a fazer. O smbolo para um enabled flip-flop dado na Figura 3.10 (c).
Figura 3.10 Enabled flip-flop: (a,b) esquemticos, (c) smbolo
3.2.6. Resettable Flip-Flop

Um resettable flip-flop possui outra entrada chamada RESET. Quando RESET for FALSE, o resettable flip-
flop comporta-se como um flip-flop D comum. Quando RESET for TRUE, o Resettable flip-flop ignora D e
repe a sada para 0. Os resettable flip-flops so teis quando queremos forar um estado conhecido (ou
seja, 0) em todos os flip-flops num sistema quando ligado pela primeira vez.
Estes flip-flops podem ser sncronos ou assncronos. Os resettable flip-flop sncronos fazem reset a eles
prprios apenas no flanco ascendente do relgio CLK. Os resettable flip-flop assncronos fazem reset a eles
prprios, logo que RESET se torne TRUE, independente do CLK.
148
A Figura 3.11 (a) mostra como construir um resettable flip-flop sncrono atravs de um flip-flop D
comum e uma porta AND. Quando for FALSE, a porta AND fora um 0 na entrada do flip-flop.
for TRUE, a porta AND passa D ao flip-flop. Neste exemplo,
Quando um sinal activo a
baixo, o que significa que o sinal de reset executa a sua funo quando est a 0, e no a 1. Ao adicionar
um inversor, o circuito poderia ter aceite em alternativa um sinal de reset activo a baixo. A Figura 3.11 (b)
e Figura 3.11 (c) mostram os smbolos para um resettable flip-flop com reset activo a alto.
Figura 3.11 Resettable flip-flop sncrono: (a) esquemticos, (b, c) smbolos
Um resettable flip-flop assncrono requer modificar a estrutura interna do flip-flop e so deixados para
que o leitor o possa projetar no Exerccio 3.13; no entanto, eles esto frequentemente disponveis para o
projetista como um componente padro.
Como o leitor pode imaginar, os settable flip-flops tambm so usados ocasionalmente. Eles carregam
um 1 no flip-flop quando SET ativado, e tambm esto disponveis na verso sncronas e assncronas. Os
resettable e settable flip-flop tambm podem ter uma entrada de habilitao e podem ser agrupados em
registros de N-bit.
3.2.7. Projeto de Bsculas e Flip-Flops a Nvel do Transstor*
O Exemplo 3.1 mostrou que bsculas e flip-flops exigem um grande nmero de transstores quando
construdas a partir de portas lgicas. Mas o papel fundamental de uma bscula ser transparente ou
149
opaca, muito parecido com um interruptor. Lembre-se da seco 1.7.7 em que uma porta de transmisso
uma forma eficiente de construir um interruptor CMOS, ento podemos esperar que poderamos tirar
proveito das portas de transmisso para reduzir a contagem do transstor.
Uma bscula compacta D pode ser construda a partir de uma nica porta de transmisso, como
= 0, a porta de transmisso est ON, ento D flui para
mostrado na Figura 3.12 (a). Quando CLK = 1 e
Q e a bscula est transparente. Quando CLK = 0 e = 1, a porta de transmisso est OFF, ento Q est
isolado de D e a bscula est opaca. Esta bscula sofre de duas grandes limitaes:
N de sada flutuante: Quando a bscula est opaca, Q no mantido no seu valor por nenhuma das
portas. Assim Q chamado de n flutuante ou dinmico. Depois de algum tempo, rudo e corrente de fugas
podem perturbar o valor de Q.
Sem buffer: A ausncia de buffers causou defeitos em vrios produtos comerciais. Um aumento de
rudo que puxe D a uma tenso negativa pode ligar o transstor nMOS, tornando a bscula transparente,
mesmo quando CLK = 0. Da mesma forma, um aumento de D acima de VDD pode ligar o transstor pMOS
mesmo quando CLK = 0. E a porta de transmisso simtrica, por isso, pode conduzir para trs com o rudo
em Q a afetar a entrada D. A regra geral que nem a entrada de uma porta de transmisso nem o n de
estado de um circuito sequencial pode ser continuamente exposto ao mundo exterior, onde o rudo
provvel.

Este circuito assume que CLK e A Figura 3.12 (b) mostra uma bscula D de 12 transstores mais robusta utilizada em chips comerciais
esto ambos disponveis. Se no, modernos. Ela ainda construda em torno de uma porta de transmisso chaveada, mas acrescenta
mais dois transstores so
inversores I1 e I2 para isolar a entrada e a sada. O estado da bscula realizado no n N1. O inversor I3 e
necessrios para um inversor de
o buffer tristate, T1, fornece realimentao para transformar N1 num n esttico. Se uma pequena
CLK.
quantidade de rudo ocorre em N1 enquanto CLK = 0, T1 ir conduzir N1 de volta para um valor lgico vlido.
A Figura 3.13 mostra um flip-flop D construdo a partir de duas bsculas estticas controladas pelo CLK e
. Alguns inversores internos redundantes foram removidos, de modo que o flip-flop requer apenas 20

transstores.
150
Figura 3.12 Esquemtico de uma bscula D
Figura 3.13 Esquemtico de um flip-flop D
3.2.8. Colocando Tudo Junto

Bsculas e flip-flops so os blocos fundamentais dos circuitos sequenciais. Lembre-se que uma bscula
D sensvel ao nvel, enquanto que um flip-flop D disparado por borda. A bscula D transparente
quando CLK = 1, permitindo que a entrada D flua para a sada Q. O flip-flop D copia D para Q no flanco de
subida de CLK. Em todas as outras situaes, bsculas e flip-flops mantm seu estado anterior. Um registro
um banco de vrios flip-flops D que compartilham um sinal CLK comum.
151
Exemplo 3.2 COMPARAO DE FLIP-FLOPS E BSCULAS

Ben Bitdiddle aplica as entradas CLK e D apresentados na Figura 3.14 a uma bscula D e a um flip-flop D.
Ajude a determinar a sada, Q, de cada dispositivo.
Soluo: A Figura 3.15 mostra as formas de onda da sada, assumindo um pequeno atraso para Q para
responder s alteraes da entrada. As setas indicam a causa de mudana de uma sada. O valor inicial de
Q desconhecido e pode ser 0 ou 1, como indicado pelo par de linhas horizontais. Primeiro, considerando
a bscula. No primeiro flanco de subida do CLK, D = 0, ento Q definitivamente torna-se 0. Sempre que D
muda enquanto CLK = 1, Q tambm o segue. Quando D muda enquanto CLK = 0, ele ser ignorado. Agora
considere o flip-flop. Em cada flanco de subida do CLK, D copiado para Q. Em todas as outras vezes, Q
mantm o seu estado.
Figura 3.14 Exemplo de forma de onda
Figura 3.15 Forma de onda da soluo
152
3.3. PROJETO DE LGICA SNCRONA

Em geral, os circuitos sequenciais incluem todos os circuitos que no so combinatrios - ou seja,
aqueles cuja resultado no pode ser determinado simplesmente olhando para as entradas atuais. Alguns
circuitos sequenciais so simplesmente magnficos. Esta seo comea por examinar alguns desses
circuitos interessantes. Em seguida, introduz a noo de circuitos sequenciais sncronos e a disciplina
dinmica. Disciplinando-nos ns prprios nos circuitos sequenciais sncronos, podemos desenvolver
modos fceis e sistemticos para analisar e projetar sistemas sequenciais.
3.3.1. Alguns Circuitos Problemticos
Exemplo 3.3 CIRCUITOS ASTVEIS
Alyssa P. Hacker encontrou trs inversores interligados numa malha, como se mostra na Figura 3.16.
A sada do terceiro inversor realimentado para o primeiro inversor. Cada inversor tem um atraso de
propagao de 1 ns. Determinar o que o circuito faz.
Soluo: Suponha que o n X est inicialmente a 0. Ento, Y = 1, Z = 0, e, portanto, X = 1, o que Figura 3.16 Trs inversores em malha
inconsistente com a nossa hiptese inicial. O circuito no tem estados estveis e diz-se ser astvel ou
instvel. A Figura 3.17 apresenta o comportamento do circuito. Se X sobe no instante 0, Y vai cair em 1
ns, Z ir subir em 2 ns, e X vai cair de novo em 3 ns. Por sua vez, Y vai subir em 4 ns, Z vai cair em 5 ns, e
X vai subir novamente em 6 ns, e, em seguida, o padro ir se repetir. Cada n oscila entre 0 e 1, com
um perodo (tempo de repetio) de 6 ns. Este circuito chamado um oscilador em anel.
O perodo do oscilador em anel depende do atraso de propagao de cada inversor. Este atraso
depende da forma como o inversor foi fabricado, da tenso de alimentao, e at mesmo da
temperatura. Portanto, o perodo de funcionamento do anel oscilador difcil de prever com preciso.
Em suma, o oscilador em anel um circuito sequencial com zero entradas e uma sada, que muda
periodicamente.
153
Figura 3.17 Formas de onda do oscilador em anel
Figura 3.18 Uma bscula D melhorada (?)
Figura 3.19 Formas de onda ilustrando as condies de corrida da bscula
154
Exemplo 3.4 CONDIES DE CORRIDA

Ben Bitdiddle desenhou uma nova bscula D que alega ser melhor do que a da Figura 3.7, porque usa
menos portas. Ele escreveu a tabela verdade para encontrar a sada, Q, dadas as duas entradas, D e CLK,
e o antigo estado da partida, Qprv. Com base nesta tabela verdade, ele obteve as equaes Booleanas.
Ele obtm Qprv realimentando a sada, Q. O seu projeto mostrado na Figura 3.18. A sua bscula trabalha
corretamente, independente dos atrasos de cada porta?
Soluo: A Figura 3.19 mostra que o circuito tem uma condio de corrida que faz com que ele falhe
quando certas portas so mais lentas do que outras. Supondo CLK = D = 1. A bscula transparente e
passa D para fazer Q = 1. Agora, CLK cai. A bscula deve-se lembrar do seu valor antigo, mantendo Q =
1. No entanto, suponha que o atraso atravs do inversor de CLK para bastante longo, em
comparao com os prazos de portas AND e OR. Ento os ns N1 e Q podem ambos cair antes que

suba. Nesse caso, N2 nunca ir subir, e Q fica preso a 0
Este um exemplo de projeto de circuito assncrono em que as sadas esto diretamente
realimentadas para as entradas. Os circuitos assncronos so conhecidos por terem condies de
corrida, onde o comportamento do circuito depende de qual dos dois caminhos atravs de portas lgicas
mais rpido. Um circuito pode trabalhar, enquanto um aparentemente idntico, construdo a partir
de portas com atrasos um pouco diferentes, pode no funcionar. Ou o circuito pode funcionar apenas
em determinadas temperaturas e tenses em que os atrasos esto corretos. Estas avarias so
extremamente difceis de rastrear.
3.3.2. Circuitos Sequenciais Sncronos

Os dois exemplos anteriores contm circuitos chamados caminhos cclicos, nos quais as sadas so
realimentadas diretamente para as entradas. Eles so circuitos sequenciais em vez de circuitos
combinatrios. A lgica combinatria no tem caminhos cclicos e nem restries de corrida. Se as
entradas so aplicadas lgica de combinaes, as sadas tero sempre o valor correto dentro de um
atraso de propagao. No entanto, os circuitos sequenciais com caminhos cclicos podem ter corridas
155
O tpcq representa o tempo de indesejveis ou comportamento instvel. A anlise de problemas nesses circuitos demorada, e muitas
propagao do relgio para Q, em que pessoas brilhantes cometeram erros.
Q indica a sada do circuito sequencial
Para evitar estes problemas, os projetistas quebram os caminhos cclicos atravs da insero de
sncrono. O tccq significa o tempo de
registros algures no caminho. Isso transforma o circuito numa coleo de lgica combinatria e de
contaminao a partir do relgio para
Q. Estes so anlogos ao tpd e tcd na registros. Os registros contm o estado do sistema, que muda apenas no flanco do relgio, por isso
lgica combinatria. dizemos que o estado sincronizado com o relgio. Se o relgio suficientemente lento, de modo que
as entradas para todos os registros estejam definidas antes da prxima transio de relgio, todas as
corridas so eliminados. Adoptando esta disciplina de usar sempre registros no caminho de
Esta definio de um circuito realimentao leva-nos definio formal de um circuito sequencial sncrono.
sequencial sncrono suficiente, mas
mais restritiva do que o necessrio. Lembre-se que um circuito definido pelos seus terminais de entrada e de sada e pelas suas
Por exemplo, em microprocessadores especificaes funcionais e temporais. Um circuito sequencial tem um conjunto finito de estados
de alto desempenho, alguns registros discretos {S0, S1, ..., Sk-1}. Um circuito sequencial sncrono tem uma entrada de relgio, cujos flancos
podem receber relgios atrasados ascendentes indicam uma sequncia de tempos em que as transies de estado ocorrem. Muitas vezes
para espremer o ltimo bit de usamos os termos estado atual e prximo estado para distinguir o estado do sistema no presente do
desempenho. Da mesma forma, estado em ele vai entrar na prxima transio de relgio. A especificao funcional detalha o prximo
alguns microprocessadores usam
estado e o valor de cada sada para cada combinao possvel de valores de estado e de entrada atual.
bsculas em vez de registros. No
A especificao de tempo consiste num limite superior, tpcq, e num limite inferior, tccq, do tempo entre o
entanto, a definio adequada para
todos os circuitos sequenciais flanco de subida do relgio at que ocorram as mudanas na sada, bem como a tempo de setup e hold,
sncronos abordados neste livro e tsetup e thold, indicam quando as entradas devem estar estveis em relao ao flanco de subida do relgio.
para a maioria dos sistemas digitais
As regras de composio de circuitos sequenciais sncronos ensinam-nos que um circuito um circuito
comerciais.
sequencial sncrono, se ele possui elementos de circuito interligados de tal forma que:
Cada elemento do circuito ou um registro ou um circuito combinatrio
Pelo menos um elemento do circuito um registro
Todos os registros recebem o mesmo sinal de relgio
Cada percurso cclico contm pelo menos um registro.
Figura 3.20 Estado atual e

prximo de flip-flop
156
Circuitos sequenciais que no so sncronos so chamados de assncronos.

Um flip-flop o mais simples circuito sequencial sncrono. Ele tem uma entrada, D, um relgio, CLK,
uma sada, Q, e dois estados, {0, 1}. A especificao funcional de um flip-flop que o prximo estado
D e que a sada, Q, o estado atual, como mostrado na Figura 3.20.
Ns muitas vezes designamos o estado atual de varivel S e o prximo estado de varivel . Neste
caso, a linha depois do S indica o prximo estado, no inverso. A temporizao de circuitos sequenciais
ser analisada na Seo 3.5.
Dois outros tipos comuns de circuitos sequenciais sncronos so chamados de mquinas de estados
finitos e pipelines. Estes sero abordados mais adiante neste Captulo.
Figura 3.21 Exemplos de circuitos
157
Exemplo 3.5 CIRCUITOS SEQUENCIAS SNCRONOS

Qual dos circuitos da Figura 3.21 so circuitos sequenciais sncronos?
Soluo: O circuito (a) combinatrio, e sequencial, porque no tem registros. O (b) um circuito
sequencial simples, sem realimentao. O (c) no nem um circuito combinatrio, nem um circuito
sequencial sncrono, porque tem uma bscula que no nem um registro nem um circuito combinatrio.
Os circuitos (d) e (e) so circuitos sncronos de lgica sequencial; so duas formas de mquinas de
estados finitos, que so discutidas na Seo 3.4. O circuito (f) no nem sequencial combinatria nem
sncrona, porque tem um percurso cclico a partir da sada da lgica combinatria volta para a entrada
da mesma lgica, mas sem um registro no caminho. O circuito (g) de lgica sequencial sncrona sob a
forma de um pipeline, que estudaremos na Seo 3.6. O circuito (h) no , falando rigorosamente, um
circuito sequencial sncrono, porque o segundo registro recebe um sinal de relgio diferente do primeiro,
retardado por dois inversores de atraso.
3.3.3. Circuitos Sncronos e Assncronos

O projeto de circuitos assncronos, em teoria, mais geral do que o projeto de circuitos sncronos,
porque a temporizao do sistema no limitada pelos registros de sincronizao. Assim como os
circuitos analgicos so mais gerais do que os circuitos digitais, pois os circuitos analgicos podem usar
qualquer tenso, os circuitos assncronos so mais gerais do que circuitos sncronos, porque eles podem
usar qualquer tipo de realimentao. No entanto, os circuitos sncronos provaram ser mais fceis de
projetar e usar do que os circuitos assncronos, assim como os digitais so mais fceis do que os circuitos
analgicos. Apesar de dcadas de pesquisa sobre circuitos assncronos, praticamente todos os sistemas
digitais so essencialmente sncronos.
Claro que, os circuitos assncronos s vezes so necessrios quando se comunica entre sistemas com
diferentes relgios ou quando se recebe entradas em tempos arbitrrios, assim como os circuitos
analgicos so necessrios ao se comunicar com o mundo real de tenses contnuas. Alm disso, a
investigao em circuitos assncronos continua a gerar detalhes interessantes, alguns dos quais podem
melhorar muito os circuitos sncronos.
158
3.4. MQUINAS DE ESTADOS FINITOS

Os circuitos sequenciais sncronos podem ser desenhados nas formas apresentadas na Figura 3.22.
Estas formas so chamadas de mquinas de estados finitos (FSM). Eles obtiveram este nome porque
um circuito com k registros pode estar num de um nmero finito (2k) de estados nicos. Uma FSM
As mquinas de Moore e de Mealy
tem entradas M, N sadas, e k bits de estado. Ele tambm recebe um relgio e, opcionalmente, um
receberam o nome dos seus
sinal de reset. Uma FSM composta por dois blocos de lgica combinatria, lgica do estado seguinte inventores, investigadores que
e lgica de sada, e um registro que armazena o estado. Em cada flanco do relgio, a FSM avana para desenvolveram a teoria de
o prximo estado, que foi calculado com base no estado atual e nas entradas. Existem duas classes autmatos, os fundamentos
gerais de mquinas de estados finitos, caracterizadas pelas suas especificaes funcionais. Nas matemticos das mquinas de estado,
mquinas de Moore, as sadas dependem apenas do estado atual da mquina. Nas mquinas de na Bell Labs. Edward F. Moore (1925-
Mealy, as sadas dependem tanto do estado atual e como das entradas atuais. As mquinas de estados 2003), no deve ser confundido com o
finitos fornecem uma forma sistemtica de projetar circuitos sequenciais sncronos dada uma fundador da Intel Gordon Moore,
especificao funcional. Este mtodo ir ser explicado no restante desta seco, comeando com um publicou seu artigo seminal,
exemplo. Gedanken-experiments on Sequential
Machines em 1956. Em seguida,
3.4.1. Projeto Exemplo de FSM tornou-se professor de matemtica e
Para ilustrar a concepo das FSM, considere o problema de inventar um controlador para um cincia da computao na
semforo num cruzamento movimentado no campus. Os estudantes de engenharia esto a Universidade de Wisconsin.
deambular entre os dormitrios e os laboratrios na Av. Acadmica. Eles esto ocupados lendo sobre George H. Mealy publicou um mtodo
as FSM nos seus livros favoritos e no esto olhando para onde esto indo. Os jogadores de futebol de sntese de circuitos sequenciais em
esto a mover-se apressadamente entre os campos de atletismo e sala de jantar em Blvd. Bravado. 1955. Posteriormente, ele escreveu o
Eles esto jogando bola para trs e para frente e no esto tambm olhando para onde esto indo. primeiro sistema operativo da Bell
Vrios ferimentos graves j ocorreram no cruzamento destas duas ruas, e o decano dos estudantes Labs para o computador IBM 704. Mais
pede a Ben Bitdiddle para instalar um semforo antes que haja mortes. tarde, ele se juntou Universidade de
Harvard.
159
Figura 3.22 Mquinas de estados finitos: (a) A mquina de Moore, (b) mquina de Mealy
Ben decide resolver o problema com uma FSM. Ele instala dois sensores de trfego, TA e TB, na Av.
Acadmica e no Blvd. Bravado, respectivamente. Cada sensor indica TRUE se os alunos esto presentes
e FALSE se a rua est vazia. Ele tambm instala dois semforos, LA e LB, para controlar o trfego. Cada
luz recebe entradas digitais para especificar se ela deve estar verde, amarela ou vermelha. Por isso, a
sua FSM tem duas entradas, TA e TB, e duas sadas, LA e LB. O cruzamento com luzes e sensores so
mostrados na Figura 3.23. Ben fornece um relgio com um perodo de 5 segundos. Em cada pulso de
relgio (flanco ascendente), as luzes podem mudar de acordo com os sensores de trfego. Ele tambm
fornece um boto de reset para que os tcnicos possam colocar o controlador num estado inicial
conhecido ao lig-lo. A Figura 3.24 mostra uma vista da caixa preta da mquina de estados.
O prximo passo de Ben esboar o diagrama de transio de estado, mostrado na Figura 3.25, para
indicar todos os possveis estados do sistema e as transies entre esses estados. Quando o sistema
reiniciado, as luzes esto verde na Av. Acadmica e vermelho em Blvd. Bravado. A cada 5 segundos, o
controlador examina o padro de trfego e decide o que fazer a seguir. Enquanto o trfego est presente
na Av. Acadmico, as luzes no mudam. Quando j no existe trfego na Av. Acadmica, a luz da Av.
160
Acadmica torna-se amarela durante 5 segundos antes de ficar vermelha, e a luz do Blvd. Bravado fica
verde. Da mesma forma, a luz da Blvd. Bravado permanece verde enquanto o trfego est presente na
avenida, em seguida, torna-se amarela e, eventualmente, vermelha.
Figura 3.23 Mapa do campus
Figura 3.24 Vista de caixa preta da mquina de estados finitos
161
Observe que os estados so

designados como S0, S1, etc. As
verses subscritas, S0, S1, etc., referem-
se aos bits de estado.
Figura 3.25 Diagrama da transio de estados
Num diagrama de transio de estado, os crculos representam os estados e os arcos representam as

transies entre estados. As transies ocorrem no flanco ascendente do relgio; que no
representado no diagrama, porque ele est sempre presente num circuito sequencial sncrono. Alm
disso, o relgio controla quando devem ocorrer as transies, enquanto que o grfico indica que
transies ocorrem. O arco ilustrado apontando do espao exterior para o estado S0 indica que o sistema
deve entrar nesse estado aps reset, independentemente do estado anterior em que se encontrava. Se
um estado tem vrios arcos deixando-o, os arcos so rotulados para mostrar que entrada aciona cada
transio. Por exemplo, quando no estado S0, o sistema ir permanecer nesse estado se TA TRUE e
passar para S1 se TA FALSE. Se um estado tem um nico arco a deix-lo, a transio ocorre sempre,
independentemente das entradas. Por exemplo, quando no estado S1, o sistema ir sempre transitar
para S2. Os valores que as sadas tm enquanto num determinado estado so indicados no estado. Por
exemplo, enquanto no estado S2, LA vermelha e LB verde.
O Ben reescreve o diagrama de transio de estado como uma tabela de transio de estado (Tabela
3.1 que indica, para cada estado e entrada, qual ser o prximo estado, S'. Note que a tabela usa o
162
smbolo (X) (dont care) sempre que o prximo estado no depende de uma entrada em particular. Alm
disso, note que Reset omitido da tabela. Em vez disso, usamos resettable flip-flops que sempre vo
para o estado S0 quando reinicia, independentes das entradas.
O diagrama de transio de estado abstrato usando estados designadas {S0, S1, S2, S3} e sadas
designadas {vermelha, amarela, verde}. Para construir um circuito real, aos estados e s sadas devem
ser atribudas codificaes binrias. Ben escolhe as codificaes dadas nas Tabela 3.2 e Tabela 3.3. Cada
estado e cada sada so codificados com dois bits: S1:0, LA1:0, e LB1:0.
Tabela 3.1 Tabela de transio de estados
Tabela 3.2 Codificao de estados
163
Tabela 3.3 Codificao das sadas
O Ben actualiza a tabela de transio do estado para usar estas codificaes binrias, como mostra a
Tabela 3.4. A tabela de transio de estado revista uma tabela verdade especificando o prximo estado
lgico. Ela define o prximo estado, S', como uma funo do estado actual, S, e das entradas.
A partir desta tabela, fcil serem lidas as equaes Booleanas para o prximo estado na forma de
soma de produtos.
1 = 1 0 + 1 0
+ 1 0
0 = 1 0
+ 1 0
(3.1)
As equaes podem ser simplificadas usando mapas de Karnaugh, mas muitas vezes faz-lo por
inspeo torna-se mais fcil. Por exemplo, os termos TB e
na equao S'1 so claramente redundantes.
Assim S'1 reduz-se a uma operao XOR. Equao 3.2 d as equaes simplificadas de prximo estados.
Tabela 3.4 Codificao binria das transies de estado
164
Tabela 3.5 Tabela de sada
1 = 1 0
(3.2)
0 = 1 0
+ 1 0

Da mesma forma, Ben escreve uma tabela de sada (Tabela 3.5), indicando, para cada estado, qual
deve ser a sada nesse estado. Novamente, fcil de serem lidas e simplificar as equaes Booleanas
para as sadas. Por exemplo, observar que LA1 TRUE apenas nas linhas onde S1 TRUE.
= 1
0 = 1 0
(3.3)
= 1
0 = 1 0
Finalmente, Ben esboa a sua FSM de Moore na forma da Figura 3.22 (a). Em primeiro lugar, ele
desenha o registro de estado de dois bits, como mostrado na Figura 3.26 (a). Em cada flanco do relgio,
o estado de registro copia o prximo estado, S'1:0, para se tornar o estado S1:0. O registro de estado
recebe um reset sncrono ou assncrono para inicializar a FSM no arranque. Em seguida, ele desenha a
lgica do prximo estado, com base na equao 3.2, que calcula o prximo estado a partir do estado
atual e das entradas, como mostrado na Figura 3.26 (b). Finalmente, ele desenha a lgica de sada, com
base na equao 3.3, que calcula as sadas a partir do estado atual, como mostrado na Figura 3.26 (c).
A Figura 3.27 mostra um diagrama temporal que ilustra o controlador de semforo passando por
uma sequncia de estados. O diagrama mostra CLK, Reset, as entradas TA e TB, o prximo estado S', o
estado S, e as sadas LA e LB. As setas indicam causalidade; por exemplo, alterando o estado faz com que
165
as sadas se alterem, e mudando as entradas faz com que o prximo estado a mude. As linhas a tracejado
indicam os flancos ascendentes do CLK, quando o estado muda.
Este esquema usa algumas portas AND
com negaes nas entradas. Elas
podem ser construdas com portas
AND e inversores de entrada, com
portas NOR e inversores para as
entradas no negadas ou com alguma
outra combinao de portas. A melhor
escolha depende da tecnologia de
implementao em particular.
Figura 3.26 Circuito da mquina de estados para o controlador de semforo
Figura 3.27 Diagrama temporal do controlador de semforo
166
O relgio tem um perodo de 5 segundos, assim os semforos mudam no mximo uma vez a cada 5
segundos. Quando a mquina de estados finitos ligada pela primeira vez, o seu estado desconhecido,
como indicado pelos pontos de interrogao. Portanto, o sistema deve ser redefinido de modo a coloc- Apesar dos melhores esforos de Ben,
os alunos no prestam ateno aos
lo num estado conhecido. Neste diagrama temporal, S redefinido imediatamente para S0, indicando
semforos e as colises continuam a
que os resettable flip-flops assncronos esto sendo usados. No estado S0, a luz LA est verde e a luz LB
ocorrer. O decano dos estudantes
est vermelha. pergunta-lhe a ele e Alyssa para
Neste exemplo, o trfego chega imediatamente na Av. Acadmica. Portanto, o controlador permanece projetar uma catapulta para lanar os
no estado S0, mantendo LA verde mesmo que o trfego chegue no Blvd. Bravado e inicia a espera. Aps estudantes de engenharia
diretamente para os telhados dos
15 segundos, todo o trfego passou na Av. Acadmica e TA cai. No relgio seguinte, o controlador segue
seus dormitrios atravs das janelas
para o estado S1, transformando LA em amarelo. Em mais 5 segundos, o controlador prossegue para o
abertas do laboratrio, ignorando o
estado S2 em que LA fica vermelha e LB fica verde. O controlador espera no estado S2 at que todo o cruzamento problemtico. Mas isso
trfego na Blvd. Bravado passe. Ele ento transita para S3, fazendo LB amarelo. Depois de 5 segundos, o assunto para outro livro.
controlador entra no estado S0, transformando LB em vermelho e LA em verde. O processo repete
indefinidamente.
3.4.2. Codificao de Estados
No exemplo anterior, as codificaes de estado e de sada foram selecionadas arbitrariamente. Uma
escolha diferente teria resultado num circuito diferente. Uma pergunta natural como determinar a
codificao que produz o circuito com o menor nmero de portas lgicas ou o atraso de propagao mais
curto. Infelizmente, no existe uma maneira simples de encontrar a melhor codificao, exceto tentar
todas as possibilidades, o que invivel quando o nmero de estados elevado. No entanto, muitas
vezes possvel escolher uma boa codificao por inspeo, para que os estados ou as sadas relacionadas
partilhem bits. Ferramentas computer-aided (CAD) so tambm boas na busca do conjunto de possveis
codificaes e selecionando um razovel.
Uma deciso importante na codificao de estados a escolha entre codificao binria e a codificao
one-hot. Com codificao binria, como foi usada no exemplo do controlador de semforo, cada estado
est representado como um nmero binrio. Como os K nmeros binrios a poderem ser representados
pelos log2K bits, um sistema com K estados apenas necessita de log2K bits de estado.
167
Na codificao one-hot, um bit separado de estado usado para cada estado. Chama-se one-hot
porque apenas um bit est "quente" ou verdadeiro em qualquer momento. Por exemplo, uma FSM
codificada em one-hot com trs estados teria codificaes de estados de 001, 010 e 100. Cada bit de
estado armazenado num flip-flop, ento uma codificao one-hot requer mais flip-flops do que a
codificao binria. No entanto, com a codificao one-hot, a lgica de prxima estado e sada muitas
vezes mais simples, de modo que so necessrios menos portas. A melhor escolha de codificao
depende do FSM especfico.
Exemplo 3.6 CODIFICAO DOS ESTADOS DE UMA FSM

Um contador de diviso-por-N possui uma sada e no tem entradas. A sada Y est HIGH para N ciclos
de relgio. Em outras palavras, a sada divide a frequncia do relgio por N. O diagrama de transio de
estado e a forma de onda para um contador divisor-por-3 mostrado na Figura 3.28. Esboce o circuito
para este contador usando codificao de estado binrio e one-hot.
Figura 3.28 Contador divide-por-3 (a), forma de onda e (b) diagrama de transio de estado
Soluo: As Tabela 3.6 e Tabela 3.7 mostram as transies de estado e sada antes da codificao.
A Tabela 3.8 compara a codificao binria e one-hot para os trs estados.
A codificao binria usa dois bits de estado. Usando esta codificao, a tabela de transio de estado
mostrada na Tabela 3.9. Note-se que no existem entradas; o prximo estado depende apenas do
168
estado atual. A tabela de sada deixada como um exerccio para o leitor. As equaes de prximo estado
e de sada so:
1 = 1 0
0 = 1 0 (3.4)
= 1 0 (3.5)
Tabela 3.6 Tabela de transio de estado do contador divide-por-3
Tabela 3.7 Tabela de sada do contador divide-por-3
A codificao one-hot usa trs bits de estado. A tabela de transio de estado para esta codificao
mostrada na Tabela 3.10 e a tabela de sada novamente deixada como um exerccio para o leitor. As
equaes de prximo estado e de sada so as seguintes:
2 = 1
1 = 0 (3.6)
0 = 2
= 0 (3.7)
169
A Figura 3.29 mostra os esquemas para cada um destes projetos. Note-se que o hardware para o
projeto da codificada binria poderia ser optimizado para compartilhar a mesma porta entre Y e S'0.
Observe tambm que a codificao one-hot requer flip-flops com (s) settable e (r) resettable para
inicializar a mquina para S0 no arranque. A melhor escolha de implementao depende do custo
relativo das portas e dos flip-flops, mas o projeto one-hot geralmente prefervel para este exemplo
especfico.
Tabela 3.8 Codificaes e binria e one-hot para contador dividir-por-3
Tabela 3.9 Tabela de transio de estado com codificao binria
Tabela 3.10 Tabela de transio de estado com codificao one-hot
170
Uma maneira fcil de lembrar a

diferena entre os dois tipos de
mquinas de estados finitos que uma
mquina de Moore geralmente tem
mais estados do que uma mquina de
Mealy para um determinado
problema.
Figura 3.29 Contador divide-por-3 (a), forma de onda e (b) diagrama de transio de estado
3.4.3. Mquinas de Moore e de Mealey

At agora, temos mostrado exemplos de mquinas de Moore, na qual a sada depende apenas do
estado do sistema. Assim, nos diagramas de transio de estado para mquinas de Moore, as sadas so
rotuladas nos crculos. Lembre-se que as mquinas de Mealy so muito parecidas com as mquinas de
Moore, mas as sadas podem depender tanto das entradas, como do estado atual. Assim, nos diagramas
de transio de estado para mquinas de Mealy, as sadas so colocadas nos arcos em vez de nos crculos.
O bloco de lgica combinatria que calcula as sadas usa o estado atual e as entradas, como foi mostrado
na Figura 3.22 (b).
Exemplo 3.7 MQUINA DE MOORE VS MQUINA DE MEALY

Alyssa P. Hacker dono de um caracol robtico de estimao com um crebro FSM. O caracol rasteja
a partir da esquerda para a direita ao longo de uma fita de papel contendo uma sequncia de 1 e 0. Em
cada ciclo de clock, o caracol rasteja para o prximo bit. O caracol sorri quando os dois ltimos bits ao
longo dos quais se arrastou so, da esquerda para a direita, 01. Projete a FSM para calcular quando o
caracol deve sorrir. A entrada A a parte debaixo das antenas do caracol. A sada Y TRUE quando o
171
caracol sorri. Compare os projetos das mquinas de estado de Moore e Mealy. Esboce um diagrama
temporal para cada mquina que mostra a entrada, os estados e a sada quando o caracol de Alyssa se
arrasta ao longo da sequncia 0100110111.
Soluo: A mquina de Moore requer trs estados, como mostrado na Figura 3.30 (a). Considere que
o diagrama de transio de estado est correto. Em particular, por que que h um arco de S2 para S1
quando a entrada est a 0?
Em comparao, a mquina Mealy requer apenas dois estados, como mostrado na Figura 3.30 (b)
(arco identificado como A/Y. A o valor da entrada que causa essa transio, e Y a sada
correspondente.
As Tabela 3.11 e Tabela 3.12 mostram a transio de estado e tabela de sada para a mquina de
Moore. A mquina de Moore requer pelo menos dois bits de estado. Considere o uso da codificao
binria de estado: S0 = 00, S1 = 01, e S2 = 10. As Tabela 3.13 e Tabela 3.14 reescrevem as tabelas de
transio de estado e de sada com estas codificaes.
A partir dessas tabelas, encontramos as seguintes equaes de estado e de sada por inspeo. Note-
se que estas equaes so simplificadas fazendo uso do fato de que o estado 11 no existe. Deste
modo, o prximo estado e sada correspondente para o estado que no existe so dont care (no
mostrado nas tabelas). Usamos os dont care para minimizar as nossas equaes.
1 = 0 (3.8)
0 =
= 1 (3.9)
A Tabela 3.15 mostra a transio de estado e de sada para a mquina de Mealy. A mquina de
Mealy requer apenas um bit de estado. Considere o uso de uma codificao de estado binria: S0 = 0
e S1 = 1. A Tabela 3.16 reescreve a transio de estado e de sada com estas codificaes.
A partir dessas tabelas, encontramos as seguintes equaes de estado e de sada por inspeo.
0 = (3.10)
172
= 0 (3.11)
Os esquemas das mquinas de Moore e de Mealy so mostrados na Figura 3.31. Os diagramas
temporais para cada mquina so mostrados na Figura 3.32. As duas mquinas seguem uma sequncia
diferente de estados. Alm disso, a sada da mquina Mealy sobe um ciclo mais cedo porque responde
entrada em vez de esperar a mudana de estado. Se a sada da mquina de Mealy fosse atrasada atravs
de um flip-flop, ela iria coincidir com a sada da mquina de Moore. Quando escolher o seu estilo do
projeto da FSM, o leitor deve considerar quando quer que as suas sadas respondam.
Figura 3.30 Diagramas de transio de estado da FSM: (a) A mquina de Moore, (b) mquina de
Mealy
Tabela 3.11 Tabela de transio de estado da mquina de Moore
173
Tabela 3.12 Tabela de sada da mquina de Moore
Tabela 3.13 Tabela de transio de estado da mquina de Moore com codificaes de estado
Tabela 3.14 Tabela de sada da mquina de Moore com codificaes de estado
174
Tabela 3.15 Tabela de transio de estado e sada da mquina de Mealy
Tabela 3.16 Tabela de transio de estado da mquina de Mealy com codificaes de estado
175
3.4.4. Factoring Mquinas de Estado

O projeto de FSM complexas frequentemente mais fcil se elas forem divididas em vrias
mquinas de estado mais simples que interagem de tal modo que as sadas de algumas mquinas so
as entradas de outras. Esta aplicao da hierarquia e modularidade chamada de factoring de
mquinas de estado.
Figura 3.31 Esquemas de FSM para mquinas (a) Moore e (b) de Mealy
Figura 3.32 Diagramas temporais para as mquinas de Moore e de Mealy
176
Exemplo 3.8: MQUINAS DE ESTADO UNFACTORED E FACTORED

Modifique o controlador de semforo da Seo 3.4.1 para ter um modo de desfile, o que mantm a
luz verde para o Boulevard Bravado enquanto os espectadores e a banda marcham para jogos de futebol
em grupos dispersos. O controlador recebe mais duas entradas: P e R. Ativando P por pelo menos um
ciclo entra-se no modo de desfile. Ativando R durante pelo menos um ciclo sai-se do modo de desfile.
Quando em modo de desfile, o controlador procede atravs de sua sequncia normal at LB ficar verde,
em seguida, permanece nesse estado com LB verde at que o modo desfile termine.
Em primeiro lugar, esboce um diagrama de transio de estado para uma nica FSM, como mostrado
na Figura 3.33 (a). Em seguida, esboce os diagramas de transio de estado para duas FSM interagindo,
como mostrado na Figura 3.33 (b). O Modo FSM ativa a sada M quando se est no modo de desfile. A
Lights FSM controla as luzes com base em M e nos sensores de trfego, TA e TB.
Soluo: A Figura 3.34 (a) mostra o desenho da EFM. Os estados S0 a S3 lidam com o modo normal. Os
estados S4 a S7 lidam com o modo desfile. As duas metades do diagrama so quase idnticas, mas no
modo de parada, a FSM permanece no estado S6 com a luz verde no Blvd. Bravado. As entradas P e R
controlam o movimento entre estas duas metades. O projeto de FSM confuso e entediante. A Figura
3.34 (b) mostra o projeto factored da FSM. O Modo FSM tem dois estados para controlar se as luzes esto
no modo normal ou no modo desfile. A Ligth FSM modificada para permanecer em S2, enquanto M
TRUE.
177
Figura 3.33 Projetos para a FSM controlador de trfego modificada a) nico e (b) factored
178
Figura 3.34 Diagrama de transio de estados: (a) no factored (b) factored
3.4.5. Obtendo uma FSM de um Esquema

A derivao do diagrama de transio de estado a partir de um esquema segue quase o processo
inverso do projeto de uma FSM. Este processo pode ser necessrio, por exemplo, quando se pega num
projeto com documentada incompleta ou caso seja necessrio fazer engenharia reversa do sistema de
outra pessoa.
179
Examine o circuito, ativando as entradas, sadas, e bits de estado.

Escreva as equaes dos prximos estado e de sada.
Crie as tabelas dos prximos estado e de sada.
Reduza a tabela de prximo estado para eliminar estados inacessveis.
Atribua a cada combinao de bits de estado vlidos um nome.
Reescreva a tabela de prximo estado e de sada com nomes de estado.
Desenhe o diagrama de transio de estado.
Escreva por palavras o que a FSM faz.
Na etapa final, deve ter o cuidado de descrever sucintamente o objetivo global e funo da FSM -
No basta voltar a descrever cada transio do diagrama de transio de estado.
Exemplo 3.9 OBTER UMA FSM DO SEU CIRCUITO

Alyssa P. Hacker chega em casa, mas o teclado do seu acesso foi religado e o seu cdigo antigo no
funciona. Um pedao de papel est colado a ele tal como se mostra no diagrama do circuito da Figura
3.35. Alyssa pensa que o circuito poder ser uma mquina de estados finitos e decide derivar o
diagrama de transio de estado para ver a ajuda a abrir a porta.
Soluo: Alyssa comea por examinar o circuito. A entrada A1:0 e a sada Unlock. Os bits de estado
j esto marcados na Figura 3.35. Esta uma mquina de Moore, porque a sada depende apenas dos
bits de estado. Do circuito, ela retira diretamente as equaes de prximo estado e de sada:
1 = 0
1 0

0 = 1 0 1 0 (3.12)
= 1
180
Figura 3.35 Circuito da FSM encontrada no Exemplo 3.9
Em seguida, ela escreve as equaes das tabelas de prximo estado e de sada, como mostrado nas
Tabela 3.17 e Tabela 3.18, colocando primeiro 1 nas posies das tabelas como indicado pela Equao
3.12. Ela coloca em seguida 0 nos restantes lugares.
Alyssa reduz a tabela, removendo os estados no utilizados e combinando linhas dont cares. O estado
S1:0 = 11 nunca listado como sendo um possvel prximo estado na Tabela 3.17, ento as linhas com este
estado atual so removidas. Para o estado atual S1:0 = 10, o prximo estado sempre S1:0 = 00,
independentemente das entradas, por isso dont care so inseridos para as entradas. As tabelas reduzidas
so mostradas nas Tabela 3.19 e Tabela 3.20.
Ela atribui nomes a cada combinao de bits de estado: S0 S1:0 = 00, S1 S1:0 = 01 e S2 S1:0 = 10. As
Tabela 3.21 e Tabela 3.22 mostram as tabelas de prximo estado e de sada com os nomes de estado.
181
Tabela 3.17 Tabela de prximo estado derivada do circuito na Figura 3.36
Tabela 3.18 Tabela da sada proveniente do circuito da Figura 3.35
182
Tabela 3.19 Tabela simplificada do prximo estado
Tabela 3.20 Tabela simplificada da sada
183
Tabela 3.21 Tabela simblica do prximo estado
Tabela 3.22 Tabela simblica da sada
184
Figura 3.36 Diagrama de transio de estado da FSM encontrada do Exemplo 3.9
Alyssa escreve o diagrama de transio de estado mostrado na Figura 3.36 usando as Tabela 3.21 e
Tabela 3.22. Por inspeo, ela pode ver que a mquina de estados finitos destranca a porta s depois de
detectar um valor de entrada, A1:0, de 3 seguido por um valor de entrada de 1. A porta , ento, novamente
bloqueada. Alyssa tenta este cdigo no teclado da porta e esta abre-se!
3.4.6. Reviso das FSM

As mquinas de estados finitos so uma forma poderosa de projetar sistematicamente circuitos
sequenciais a partir de uma especificao escrita. Use o seguinte procedimento para projetar um FSM:
Identifique as entradas e as sadas.
Esboce um diagrama de transio de estado.
185
Para uma mquina de Moore:

Faa uma tabela de transio de estado.
Faa uma tabela de sada.
Para uma mquina Mealy:
Escreva uma tabela combinada das transies de estado e de sada.
Selecione a codificao dos estados a sua seleo afeta o projeto do hardware.
Escreva as equaes Booleanas para a lgica do prximo estado e de sada.
Esboce o esquema de circuito.
Vamos usar repetidamente as FSM para projetar sistemas digitais complexos ao longo deste livro.
3.5. TEMPORIZAO DA LGICA SEQUENCIAL

Lembre-se que um flip-flop copia a entrada D para a sada Q no flanco ascendente do relgio. Este
processo chamado de amostragem (sampling) de D na borda ascendente do relgio. Se D est estvel
a 0 ou a 1 quando o relgio sobe, este comportamento claramente definido. Mas o que acontece se
D est mudando ao mesmo tempo que o relgio sobe?
Este problema semelhante ao que se coloca a uma cmara ao tirar uma fotografia. Imagine que
fotografa um sapo pulando de uma almofada de lrio para o lago. Se o leitor tirar a foto antes do salto,
ir ver um sapo numa almofada de lrio. Se o leitor tirar a foto depois do salto, ir ver ondulaes na
gua. Mas se o leitor tirar a foto, assim que o sapo pula, o leitor poder ver uma imagem do sapo
esborratada que se estende desde a almofada de lrio at gua. Uma cmara caracterizada pelo seu
tempo de abertura, durante o qual o objeto tem de permanecer parado para se capturar uma imagem
ntida. Do mesmo modo, um elemento sequencial tem um tempo de abertura em torno do flanco do
relgio, durante o qual a entrada deve ser estvel para que o flip-flop possa produzir uma sada bem
definida.
186
A abertura de um elemento sequencial definida por um tempo de preparao (setup) e um tempo

de espera (hold), antes e depois do flanco do relgio, respectivamente. Assim, como a disciplina esttica
nos limita a usar nveis lgicos fora da zona proibida, a disciplina dinmica nos limita ao uso de sinais
que mudam fora do tempo de abertura. Tirando proveito da disciplina dinmica, podemos pensar no
tempo em unidades discretas chamadas de ciclos de relgio, assim como ns pensamos nos nveis de
sinal como discreto 1 e 0. Um sinal pode apresentar glitch e oscilar descontroladamente por alguma
quantidade limitada de tempo. Sob a disciplina dinmica, estamos preocupados apenas sobre o seu valor
final no fim do ciclo de relgio, depois de ter normalizado num valor estvel. Assim, pode-se
simplesmente escrever A[n], como o valor do sinal A, no final do ciclo de relgio de ordem n, onde n
um nmero inteiro, em vez de A (t), o valor de A em algum instante t, em que t um qualquer nmero
real.
O perodo do relgio tem que ser longo o suficiente para todos os sinais estabilizarem. Isto define um
limite para a velocidade do sistema. Em sistemas reais, o relgio no atinge todos os flip-flops
precisamente ao mesmo tempo. Esta variao no tempo, chamada de defasagem do relgio, aumenta
ainda mais o perodo de relgio necessrio.
Algumas vezes impossvel satisfazer a disciplina dinmica, especialmente quando se faz o interface
com o mundo real. Por exemplo, considere um circuito com uma entrada proveniente de um boto. Um
macaco pode pressionar o boto apenas quando o relgio sobe. Isso pode resultar num fenmeno
chamado de metaestabilidade, onde o flip-flop captura um valor a meio caminho entre 0 e 1 que pode
levar uma quantidade ilimitada de tempo para determinar um valor lgico correto. A soluo para tais
entradas assncronas usar um sincronizador, que possui uma probabilidade muito pequena (mas
diferente de zero) de produzir um valor lgico ilegal.
Vamos expandir todos estes conceitos no restante desta seo.
3.5.1. A Disciplina Dinmica
At agora, temo-nos focado na especificao funcional dos circuitos sequenciais. Recorde-se que um
circuito sequencial sncrono, tal como um flip-flop, ou FSM, tambm tem uma especificao temporal,
tal como ilustrado na Figura 3.37. Quando o relgio sobe, a sada (ou sadas) podem comear a mudar
depois do relgio-para-Q contamination delay, tccq, e deve estabelecer definitivamente o valor final
187
dentro do relgio-para-Q propagation delay, tpcq. Estes representam os atrasos mais rpidos e mais
lentos atravs do circuito, respectivamente. Para o circuito amostrar a sua entrada corretamente, a
entrada (ou entradas) devem ter estabilizado pelo menos algum setup time, tsetup, antes do flanco de
subida do relgio e devem permanecer estveis durante pelo menos durante algum hold time, thold,
aps o flanco de subida do relgio. A soma do setup time e do hold time chamado de aperture time
do circuito, uma vez que o tempo total durante o qual a entrada deve permanecer estvel.
A disciplina dinmica afirma que as entradas de um circuito sequencial sncrono devem estar
estveis durante o setup e hold time em torno do flanco do relgio. Ao impor essa exigncia,
garantimos que os flip-flops amostram os sinais enquanto eles no esto mudando. Porque estamos
preocupados apenas sobre os valores finais das entradas no momento em que so recolhidos,
podemos tratar os sinais tanto como discretos no tempo, assim como em nveis lgicos.
3.5.2. Temporizao do Sistema
O perodo de relgio ou tempo de ciclo, Tc, o tempo entre os flancos de um sinal de relgio
repetitivo. O seu recproco, fc = 1 / Tc, a frequncia de relgio. Tudo o resto idntico, aumentando
a frequncia do relgio aumenta-se o trabalho que um sistema digital pode realizar por unidade de
tempo. A frequncia medida em unidades de hertz (Hz), ou ciclos por segundo: 1 megahertz (MHz) =
Nas trs dcadas a seguir compra de 106 Hz, e um gigahertz (GHz) = 109 Hz.
um computador Apple II+ por um
A Figura 3.38 (a) ilustra um caminho genrico num circuito sequencial sncrono cujo perodo de
familiar dos autores at ao tempo
presente de escrita, as frequncias de relgio se deseja calcular. No flanco ascendente do relgio, o registro R1 produz uma sada (ou sadas)
relgio dos microprocessadores Q1. Estes sinais entram num bloco de lgica combinatria, produzindo D2, a entrada (ou entradas)
aumentaram de 1 MHz at vrios GHz, para o registro R2. O diagrama temporal da Figura 3.38 (b) mostra que cada sinal de sada pode
um fator de mais de 1000. Esta comear a mudar com um contamination delay depois da mudana das entradas e a estabelecer-se no
acelerao explica parcialmente as valor final dentro de um tempo de atraso de propagao aps as suas entradas se estabelecerem. As
mudanas revolucionrias feitas pelos setas cinzentas representam o contamination delay atravs de R1 e da lgica combinatria, e as setas
computadores na sociedade. azuis representam o atraso de propagao atravs de R1 e da lgica combinatria. Analisamos as
restries temporais em relao ao setup time e ao hold time do segundo registro, R2.
188
Figura 3.37 Especificaes temporais para um circuito sequencial sncrono
Figura 3.38 Caminho entre registros e diagrama temporal
Restrio do Setup Time

Na Figura 3.39 o diagrama temporal mostra apenas o atraso mximo atravs do percurso, indicado
pelas setas azuis. Para satisfazer o setup time de R2, D2 deve estabelecer-se o mais tardar antes do setup
time da prxima transio de relgio. Assim, encontramos uma equao para o perodo de relgio
mnimo:
+ + (3.13)
189
Em projetos comerciais, o perodo de relgio muitas vezes ditado pelo Diretor de Engenharia ou
pelo departamento de marketing (para garantir um produto competitivo). Alm disso, o propagation
delay e o setup time do relgio-para-Q do flip-flop, tpcq e tsetup, so especificados pelo fabricante. Por
isso, reescrevemos a Equao 3.13 em ordem ao atraso mximo de propagao atravs da lgica
combinatria, que normalmente a nica varivel sob o controlo do projetista.
( + ) (3.14)
O termo entre parnteses, tpcq + tsetup, chamado de sobrecarga de sequenciamento (sequencing

overhead). Idealmente, o tempo total de ciclo Tc estaria disponvel para realizar clculo til na lgica
combinatria, tpd. No entanto, a sobrecarga de sequencial do flip-flop reduz este tempo. A Equao 3.14
chamada de setup time constraint ou de max-delay constraint, porque depende do setup time e limita
o atraso mximo atravs da lgica combinatria.
Figura 3.39 Max-delay para o setup time constraint
Se o atraso de propagao atravs da lgica combinatria muito grande, D2 pode no ser ter
estabelecido no seu valor final no momento em que R2 precisa dele estvel para que o possa amostrar.
Assim, R2 pode amostrar um resultado incorreto ou mesmo um nvel lgico ilegal, num nvel na regio
proibida. Em tal caso, o circuito ter um funcionamento incorreto. O problema pode ser resolvido
aumentando o perodo de relgio ou redesenhando a lgica combinatria para que tenha um atraso de
propagao mais curto.
190
Restrio do Hold Time

O registro R2 na Figura 3.38 (a) tambm tem uma hold time constraint. A sua entrada, D2, no deve
mudar at algum tempo, thold, aps o flanco ascendente do relgio. De acordo com a Figura 3.41, D2 pode
mudar assim que tccq + tcd a seguir ao flanco ascendente do relgio. Assim, encontramos
+ (3.15)
Mais uma vez, tccq e thold so caractersticas do flip-flop que esto geralmente fora do controle do
projetista. Reorganizando, podemos resolver para o mnimo de contamination delay atravs da lgica
combinatria:
(3.16)
A equao 3.16 tambm chamada de hold time constraint ou min-delay constraint porque limita o
atraso mnimo atravs da lgica combinatria.
Assumimos que quaisquer elementos lgicos podem ser ligados uns aos outros sem a introduo de
problemas de tempo. Em particular, seria de esperar que dois flip-flops possam ser ligados diretamente
em cascata como na Figura 3.40, sem causar problemas de hold time.
Em tal caso, o tCd = 0 porque no h nenhuma lgica combinatria entre os flip-flops. Substituindo na
equao 3.16 produz o requisito de que
(3.17)
191
Figura 3.41 Min-delay para o hold time constraint
Por outras palavras, um flip-flop de confiana deve ter um hold time mais curto do que o seu
Figura 3.40 flip-flops Back-to-back
contamination delay. Muitas vezes, os flip-flops so projetados com thold = 0, de modo que a Equao
3.17 sempre satisfeita. Salvo disposio em contrrio, vamos geralmente fazer essa suposio e
ignorar a restrio do hold time neste livro.
No entanto, as restries do hold time so extremamente importantes. Se violadas, a nica soluo
consiste em aumentar o contamination delay atravs da lgica, o que exige o redesenho do circuito. Ao
contrrio da restrio do setup time, que no pode ser corrigido, ajustando o perodo de relgio.
Projetar um circuito integrado e fabricar o projeto corrigido leva meses e milhes de dlares nas atuais
tecnologias, por isso, assim os hold time violations devem ser levados muito a srio.
Juntando Tudo
Os circuitos sequenciais tm restries de setup e hold time e de espera que ditam os atrasos
mnimos e mximos da lgica combinatria entre flip-flops. Os flip-flops modernos so normalmente
concebidos de modo a que o atraso mnimo atravs da lgica combinatria seja de 0, isto , os flip-flops
pode ser colocado back-to-back. A restrio de atraso mximo limita o nmero de portas consecutivas
sobre o caminho crtico de um circuito de alta velocidade, porque uma frequncia elevada de relgio
significada um curto perodo de relgio.
192
Exemplo 3.10 ANLISE TEMPORAL

Ben Bitdiddle desenhou o circuito na Figura 3.42. De acordo com as folhas de dados para os
componentes que ele est usando, os flip-flops tm um contamination delay de relgio-para-Q de 30 ps e
um atraso de propagao de 80 ps. Eles tm um setup time de 50 ps e um hold time de 60 ps. Cada porta
lgica tem um atraso de propagao de 40 ps e um contamination delay de 25 ps. Ajude o Ben a
determinar a frequncia mxima do relgio e se alguma violao do hold time poder ocorrer. Este
processo chamado de anlise temporal (timing analysis).
Figura 3.42 Circuito de exemplo para anlise temporal

Figura 3.43 Diagrama temporal:
Soluo: A Figura 3.43 (a) mostra as formas de onda que ilustram quando os sinais podem mudar. As (a) caso geral, (b) caminho crtico,
entradas, A a D, passam por registros, ento elas s se alteram um pouco depois do CLK subir. (c) caminho curto
O caminho crtico ocorre quando B = 1, C = 0, D = 0, e A sobe de 0 a 1, levando n1 a subir, X' a subir, e
Y' a descer, conforme se mostra na Figura 3.43 (b). Este caminho envolve trs atrasos de porta. Para o
caminho crtico, assumimos que cada porta requer a totalidade do seu atraso de propagao. Y' deve estar
preparado antes do prximo flanco ascendente do CLK. Assim, o tempo de ciclo mnimo
+ 3 + = 80 + 3 40 + 50 = 250 (3.18)
A frequncia mxima de relgio fc = 1 / Tc = 4 GHz.
193
Um caminho curto ocorre quando A = 0 e C sobe, fazendo com que X suba, como se mostra na Figura
3.43 (c). Para o caminho curto, assumimos que cada porta se altera aps um contamination delay. Este
caminho envolve apenas um atraso de porta, por isso pode ocorrer aps tccq + tcd = 30 + 25 = 55 ps. Mas
lembre-se de que o flip-flop tem um tempo de espera de 60 ps, o que significa que X' deve permanecer
estvel durante 60 ps aps o flanco ascendente do CLK para que o flip-flop possa amostrar de forma
confivel o seu valor. Neste caso, X' = 0 no primeiro flanco ascendente do CLK, por isso queremos que o
flip-flop capture X = 0. Porque X' permanece estvel o tempo suficiente, o valor atual de X imprevisvel.
O circuito tem uma violao do hold time e pode comportar-se de forma irregular a qualquer frequncia
de relgio
Exemplo 3.11 RESOLUO DA VIOLAO DO HOLD TIME

Alyssa P. Hacker prope para corrigir circuito do Ben adicionar buffers para abrandar o caminho curto,
como mostrado na Figura 3.44. Os buffers tm os mesmos atrasos que as outras portas. Determine a
frequncia mxima do relgio e se ser de esperar outros problemas de tempo.
Soluo: A Figura 3.45 mostra as formas de onda ilustrando quando os sinais podem mudar. O caminho
crtico de A a Y no afetado, uma vez que no passa atravs de qualquer buffer. Portanto, a frequncia
mxima de relgio ainda de 4 GHz. No entanto, os caminhos curtos so retardados pelo atraso de
contaminao do buffer. Agora, X' no mudar at que tccq + 2tcd = 30 + 2 x 25 = 80 ps. Isto , aps que o
hold time de 60 ps tenha decorrido, de modo que o circuito opera agora corretamente.
Este exemplo tinha um hold time invulgarmente longo para evidenciar os problemas de hold time. A
maioria dos flip-flops so projetados com thold < tccq para evitar tais problemas.
194
Figura 3.44 Circuito corrigido para resolver o problema do hold time
Figura 3.45 Diagrama temporal com buffers para resolver o problema do hold time
No entanto, alguns microprocessadores de alto desempenho, incluindo o Pentium 4, usam um elemento

chamado uma pulsed latch em vez de um flip-flop. A pulsed latch comporta-se como um flip-flop, mas tem
um pequeno atraso de relgio-para-Q e um hold time longo. Em geral, a adio de buffers pode geralmente,
mas no sempre, resolver problemas do hold time, sem abrandar o caminho crtico.
3.5.3. Skew do Relgio*
Na anlise anterior, assumiu-se que o relgio atinge todos os registros exatamente ao mesmo tempo.
Na realidade, h alguma variao deste instante. Esta variao nos flancos do relgio chamada de
desenquadramento do relgio (clock skew). Por exemplo, as pistas da fonte de relgio para diferentes
registros podem ter diferentes comprimentos, resultando em atrasos ligeiramente diferentes, tal como
195
mostrado na Figura 3.46. O rudo tambm resulta em atrasos diferentes. O clock gating, descrito na
Seo 3.2.5, atrasa ainda mais o relgio. Se alguns relgios esto ativos e outros no, haver uma
distoro substancial entre os relgios fechados e abertos. Na Figura 3.46, CLK2 est em avano em
relao ao CLK1, porque a pista de relgio entre os dois registros segue uma rota cnica. Se a pista do
relgio tivesse sido encaminhada de forma diferente, o CLK1 poderia estar em avano. Ao fazemos
uma anlise temporal, consideramos o pior cenrio possvel, para que possamos garantir que o circuito
ir funcionar em todas as circunstncias.
A Figura 3.47 acrescenta um skew no diagrama temporal da Figura 3.38. A linha cheia do relgio
indica o ltimo momento em que o sinal de relgio pode chegar a qualquer registro; as linhas a trao
interrompido mostram que o relgio pode chegar at tskew mais cedo.
Primeiro, considere a restrio de setup time mostrada na Figura 3.48. No pior dos casos, R1 recebe
o relgio em atraso e R2 recebe o relgio em avano, deixando pouco tempo para que os dados se
possam propagar entre os registros.
Figura 3.46 Skew do relgio provocado pelo atraso no condutor
196
Figura 3.47 Diagrama temporal com skew do relgio
Os dados propagam-se atravs do registro e da lgica combinatria e devem estabilizar antes que
R2 os amostre. Assim, conclumos que
+ + + (3.19)
( + + ) (3.20)
Figura 3.48 Restrio do setup time com skew do relgio
197
Em seguida, considere a restrio de hold time mostrada na Figura 3.49. No pior dos casos, R1 recebe
um relgio em avano, CLK1, e R2 recebe um relgio em atraso, CLK2. Os dados percorrem os registros
e a lgica combinatria, mas no devem chegar at um hold time aps o ltimo relgio. Assim,
descobrimos que
+ + (3.21)
+ (3.22)
Em resumo, o skew do relgio efetivamente aumenta tanto o setup time e como o hold time. Ele
acrescenta uma sobrecarga ao sequenciamento, reduzindo o tempo disponvel para realizar trabalho til
na lgica combinatria. Tambm aumenta o atraso mnimo exigido pela lgica combinatria. Mesmo se
thold = 0, um par de flip-flops back-to-back ir violar a Equao 3.22 se tskew > tccq. Para evitar graves falhas
de hold time, os projetistas no devem permitir demasiada skew do relgio. s vezes os flip-flops so
intencionalmente concebidos para serem particularmente lentos (isto , elevado tccq), para evitar
problemas de hold time, mesmo quando o skew do relgio substancial.
Figura 3.49 Restrio do hold time com skew do relgio
198
Exemplo 3.12 ANLISE TEMPORAL COM SKEW DO RELGIO

Revisitar o Exerccio 3.10 e assumir que o sistema tem 50 ps de skew do relgio.
Soluo: O caminho crtico continua a ser o mesmo, mas o setup time efetivamente aumentado pelo skew.
Assim, o tempo de ciclo mnimo
+ 3 + + = 80 + 3 40 + 50 + 50 = 300 (3.23)
O caminho curto tambm permanece o mesmo em 55 ps. O hold time eficazmente aumentado pelo
skew para 60 + 50 = 110 ps, que muito maior do que 55 ps. Assim, o circuito ir violar o hold time e ter
um mau funcionamento a qualquer frequncia. O circuito viola a restrio do hold time , mesmo sem skew.
O skew no sistema faz a violao ser pior.
Exemplo 3.13 SOLUCIONAR A VIOLAO DO TEMPO DE ESPERA

Revisitar o Exerccio 3.11 e assumir que o sistema tem 50 ps de skew do relgio.
Soluo: O caminho crtico no afetado, ento a frequncia mxima do relgio permanece 3.33 GHz.
O caminho curto aumenta para 80 ps. Isto ainda menos do que thold + tskew = 110 ps, de modo que o
circuito ainda viola a sua restrio de tempo de espera.
Para corrigir o problema, ainda mais buffers podem ser inseridos. Os buffers que tm que ser adicionados
tambm no caminho crtico assim, reduzindo a frequncia de relgio. Alternativamente, um flip-flop com
um hold time mais curto poderia ser utilizado.
199
3.5.4. Metaestabilidade
Como observado anteriormente, nem sempre possvel garantir que a entrada para um circuito
sequencial estvel durante o aperture time, especialmente quando a entrada chega do mundo exterior.
Considere-se um boto ligado entrada de um flip-flop, como mostrado na Figura 3.50. Quando o boto
no est pressionado, D = 0. Quando o boto pressionado, D = 1. Um macaco pressiona o boto num
qualquer momento aleatrio em relao ao flanco ascendente do CLK. Queremos saber qual a sada Q
aps o flanco ascendente de CLK. No Caso I, quando o boto pressionado muito antes de CLK, Q = 1.
No Caso II, quando o boto no pressionado at muito tempo depois de CLK, Q = 0. Mas no Caso III,
quando o boto pressionado em algum momento entre tsetup antes de CLK e thold depois de CLK, a
entrada viola a disciplina dinmica e a sada indefinida.
Estado Metaestvel
Quando um flip-flop amostra uma entrada que est em mudana durante a sua abertura, a sada Q
pode assumir momentaneamente uma tenso entre 0 e VDD situada na zona proibida. Isso chamado
um estado metaestvel. Eventualmente, o flip-flop vai estabelecer a sada num estado estvel (stable
state) de 0 ou 1. Contudo, o resolution time necessrio para alcanar o estado estvel ilimitado.
Figura 3.50 Entrada modifica-se O estado metaestvel de um flip-flop anlogo a uma bola no cume de uma colina entre dois vales,
antes, depois e durante o tempo como mostrado na Figura 3.51. Os dois vales so estados estveis, porque uma bola no vale permanecer
de abertura
l, desde que no seja perturbada. O topo da colina chamado metaestvel porque a bola iria
permanecer l se fosse perfeitamente equilibrada. Mas porque nada perfeito, a bola ir rolar,
eventualmente, para um lado ou para o outro. O tempo necessrio para que essa alterao ocorra
depende de como equilibrada a bola estava originalmente. Cada dispositivo biestvel tem um estado
metaestvel entre os dois estados estveis.
Resolution Time
Se uma entrada do flip-flop muda num momento aleatrio durante o ciclo de relgio, o resolution
time, tres, necessrio para resolver para um estado estvel tambm uma varivel aleatria. Se a entrada
muda fora da abertura, ento, tres = tpcq. Mas se ocorre a entrada alterar-se dentro da abertura, tres pode
200
ser substancialmente mais longo. As anlises tericas e experimentais (ver Seo 3.5.6) mostram que a
probabilidade de que o tempo de resoluo, tres, exceda algum tempo arbitrrio, t, diminui
exponencialmente com t:

( > ) = 0 (3.24)

onde Tc o perodo de relgio, e T0 e so caractersticas do flip-flop. A equao vlida apenas para t

substancialmente maior do que tpcq. Figura 3.51 Estados estveis e
Intuitivamente, T0 / Tc descreve a probabilidade de que a entrada mude num momento inoportuno metaestveis
(isto , durante o tempo de abertura); esta probabilidade diminui com o tempo de ciclo, Tc. uma
constante de tempo indicadora do quo rpido o flip-flop se afasta do estado metaestvel; ele est
relacionado com o atraso atravs das portas do flip-flop.
Em resumo, se a entrada de um dispositivo biestvel, tal como um flip-flop, se altera durante o tempo
de abertura, a sada pode assumir um valor metaestvel durante algum tempo antes de se resolver para
o valor estvel 0 ou 1. A quantidade de tempo necessrio para resolver no tem limite, porque para
qualquer tempo finito, t, a probabilidade de que o flip-flop ainda seja metaestvel diferente de zero.
No entanto, essa probabilidade cai exponencialmente quando t aumenta. Portanto, se esperarmos o
tempo suficiente, muito mais do que tpcq, podemos esperar com uma alta probabilidade elevada que o
flip-flop chegue a um nvel lgico vlido.
3.5.5. Sincronizadores
Entradas assncronas do mundo real em sistemas digitais so inevitveis. A entrada humana
assncrona, por exemplo. Se manuseado sem cuidado, estas entradas assncronas podem levar a tenses
metaestveis dentro do sistema, causando falhas errticos no sistema que so extremamente difceis de
rastrear e corrigir. O objetivo de um projetista de um sistema digital deve ser o de assegurar que, dada
uma entrada assncrona, a probabilidade de encontrar uma tenso metaestvel suficientemente
pequena. "Suficientemente" depende do contexto. Para um telefone celular, talvez uma falha em 10
anos aceitvel, porque o utilizador pode sempre desligar o telefone e voltar a ligar se este bloquear.
201
Para um dispositivo mdico, um fracasso na vida esperada do universo (10 10 anos) um alvo melhor.
Para garantir bons nveis de lgica, todas as entradas assncronas devem ser passadas atravs de
sincronizadores.
Um sincronizador, mostrado na Figura 3.52, um dispositivo que recebe uma entrada D assncrona e
um relgio CLK. Ela produz uma sada Q dentro de um perodo limitado de tempo; a sada tem um nvel
lgico vlido com probabilidade extremamente alta. Se D estvel durante a abertura, Q deve assumir
o mesmo valor de D. Se D se altera durante a abertura, Q pode tomar um valor HIGH ou LOW, mas no
deve ser metaestvel.
A Figura 3.53 mostra uma maneira simples de criar um sincronizador a partir de dois flip-flops. F1
amostra D no flanco ascendente do CLK. Se D est a mudar naquele momento, a sada D2 pode ser
momentaneamente metaestvel. Se perodo do relgio da Figura 3.53 mostra uma maneira simples de
criar um sincronizador de dois flip-flops. Amostras F1 D na borda de subida de CLK. Se D est mudando
naquele tempo, a sada D2 pode ser momentaneamente metaestvel. Se o perodo do relgio for
Figura 3.52 Smbolo de um
suficientemente longo, D2 ser, com grande probabilidade, resolvido para um nvel lgico vlido antes
sincronizador
do final do perodo. F2, em seguida, amostra D2, que agora est estvel, produzindo uma boa sada Q.
Figura 3.53 Sincronizador simples
202
Dizemos que um sincronizador falha se Q, a sada do sincronizador, se torna metaestvel. Isso pode
acontecer se D2 no se resolveu a um nvel vlido no momento em que se deve preparar em F2, isto , se
tres > Tc - tsetup. Segundo a Equao 3.24, a probabilidade de falha para uma nica mudana da entrada num
tempo aleatrio

0
() = (3.25)

A probabilidade de falha, P (falha), a probabilidade de que a sada Q seja metaestvel numa nica
mudana de D. Se D muda uma vez por segundo, a probabilidade de falha por segundo apenas P (falha).
No entanto, se D muda N vezes por segundo, a probabilidade de falha por segundo N vezes to grande
como:

0
()/ = (3.26)

A fiabilidade do sistema geralmente medida em tempo mdio entre falhas (MTBF - mean time between
failures). Como o nome sugere, MTBF a quantidade mdia de tempo entre as falhas do sistema. o
inverso da probabilidade de que o sistema ir falhar num dado segundo
( )
1
= = (3.27)
()/ 0
A Equao 3.27 mostra que o MTBF melhora exponencialmente medida que o sincronizador de espera
durante mais tempo, Tc. Para a maioria dos sistemas, um sincronizador que espera por um ciclo de relgio
proporciona um MTBF seguro. Excepcionalmente em sistemas de alta velocidade, a espera por mais ciclos
pode ser necessria.
Exemplo 3.14 SINCRONIZADOR PARA ENTRADA DE FSM

A FSM do controlador de semforo da Seo 3.4.1 recebe entradas assncronas a partir dos sensores de
trfego. Suponha-se que um sincronizador usado para garantir entradas estveis ao controlador. O
trfego chega em mdia 0,2 vezes por segundo. Os flip-flops do sincronizador tm as seguintes
203
caractersticas: = 200 ps, T0 = 150 ps, e tsetup = 500 ps. Quanto tempo o perodo de relgio sincronizador
deve ter para que o MTBF exceda 1 ano?
Soluo: 1 ano 107 segundos. Resolvendo a equao 3.27.
5001012
2001012
107 = (0,2)(1501012 ) (3.18)
Esta equao no tem soluo de forma fechada. No entanto, bastante fcil de resolver por
tentativa e erro. Numa folha de clculo, tente alguns valores para Tc e calcule o MTBF at descobrir o
valor de Tc que d um MTBF de um ano: Tc = 3.036 ns
3.5.6. Derivada do Resolution Time*

A Equao 3.24 pode ser obtida utilizando conhecimentos bsicos de teoria de circuitos, equaes
diferenciais, e probabilidade. Esta seo pode ser ignorada se voc no est interessado na derivao
ou se voc no estiver familiarizado com a matemtica.
A sada de um flip-flop ser metaestvel depois de algum tempo, t, se o flip-flop amostrar uma
entrada em mudana (causando uma condio metaestvel) e a sada no se resolve para um nvel
vlido dentro desse tempo aps o flanco do relgio. Simbolicamente, esta pode ser expressa como
( > ) = ( ) () (3.29)
Consideramos cada termo de probabilidade individualmente. O sinal de entrada assncrona comuta
entre 0 e 1 em algum tempo, tswitch, tal como mostrado na Figura 3.54. A probabilidade de que a entrada
se altere durante a abertura em torno do flanco do relgio
+ +
( ) = (3.30)

Se o flip-flop entrar em metaestabilidade, isto , com probabilidade P(samples changing input), o

tempo para resolver a metaestabilidade depende do funcionamento interno do circuito. Este tempo de
204
resoluo determina P(unresolved), a probabilidade de que o flip-flop ainda no esteja resolvido para um
nvel lgico validade aps um tempo t. O restante desta seco analisa um modelo simples de um
dispositivo biestvel para estimar essa probabilidade.
Figura 3.54 Temporizao da entrada
Figura 3.55 Modelo do circuito de um dispositivo biestvel
Um dispositivo biestvel usa armazenamento com realimentao positiva. A Figura 3.55 (a) mostra esta
realimentao implementada com dois inversores; o comportamento deste circuito representativo da
maioria dos elementos biestveis. Um par de inversores comporta-se como um buffer. Vamos modela-lo
como tendo as caractersticas simtrica de transferncia DC mostradas na Figura 3.55 (b), com um declive
G. O buffer pode entregar apenas uma quantidade finita de corrente de sada; podemos modelar isto como
uma resistncia de sada, R. Todos os circuitos reais tambm possuem alguma capacidade C que deve ser
carregada. Carregar o condensador atravs da resistncia provoca um atraso RC, impedindo o buffer de
205
comutar instantaneamente. Por isso, o modelo do circuito completo mostrado na Figura 3.55 (c), onde
Vout (t) a tenso de interesse que transmite o estado do dispositivo biestvel.
O ponto metaestvel para este circuito Vout (t) = Vin (t) = VDD/2; se o circuito comeasse exatamente
nesse ponto, ele permaneceria l indefinidamente na ausncia de rudo. Porque as tenses so variveis
contnuas, a probabilidade de que o circuito comece exatamente no ponto metaestvel muito
pequena. No entanto, o circuito pode comear no tempo 0, perto da metaestabilidade em vout (0) =
VDD/2 + V para um pequeno desvio de V. Em tal caso, o feedback positivo ir eventualmente conduzir
Vout (t) a VDD se V > 0 e a 0 se V < 0. O tempo necessrio para atingir VDD ou 0 o tempo de resoluo
do dispositivo biestvel.
A caracterstica de transferncia DC no linear, mas parece linear perto do ponto metaestvel, que
a regio de interesse para ns. Especificamente, se vin (t) = VDD / 2 + V / G, ento Vout (t) = VDD / 2 +
V para pequenos V. A corrente atravs da resistncia i (t)= (Vout (t) - Vin (t)) / R. O condensador
carrega a uma taxa dvin (t) / dt = i (t) / C. Colocando juntos todos os factos, encontramos a equao que
governa a tenso de sada.
() (1)
= [ () ] (3.31)
2
Esta uma equao diferencial linear de primeira ordem. A resoluo usando a condio inicial vout
(0) = VDD/2 + V d
(1)

() = + (3.32)
2
A Figura 3.56 fornece vrias trajetrias para vout (t) dados vrios pontos de partida. vout (t) desloca-
se exponencialmente para longe do ponto metaestvel VDD/2 at que satura em VDD ou 0. A sada
eventualmente resolve-se para 1 ou 0. A quantidade de tempo depende do desvio (V) a partir do ponto
inicial de tenso metaestvel (VDD/2).
Resolvendo a equao 3.32 para o tempo de resoluo tres, de tal forma que vout (tres) = VDD ou 0, d
206
(1)

|| = (3.33)
2

= 1 ln 2|| (3.34)
Em resumo, o tempo de resoluo aumenta se o dispositivo biestvel tem alta resistncia ou

capacidade o que faz com que a sada mude lentamente. Ela diminui se o dispositivo biestvel tem ganho
elevado, G. O tempo de resoluo tambm aumenta algoritmicamente com o circuito a comear mais
prximo do ponto metaestvel (V 0).
Definindo como (RC) / (G-1). Resolvendo a equao 3.34 para V devolve o deslocamento inicial,
Vres, que corresponde a um tempo de resoluo em particular, tres:

= (3.35)
2
Figura 3.56 Trajetrias de resoluo
Suponha-se que um dispositivo biestvel amostra uma entrada ao mesmo tempo que esta muda. Ele
mede a tenso, vin (0), que assumimos estar uniformemente distribuda entre 0 e VDD. A probabilidade de
que a sada no se tenha resolvido para um valor legal depois do instante tres depende da probabilidade
de que o deslocamento inicial seja suficientemente pequeno. Especificamente, o deslocamento inicial na
Vout deve ser inferior a Vres, de modo que o deslocamento inicial em Vin seja ser inferior a Vres / G. Ento,
207
a probabilidade de que o dispositivo biestvel amostre a entrada num instante de tempo para obter um
nvel suficientemente pequeno do deslocamento inicial
Vres 2
() = (| (0) |< )= (3.36)
2
Colocar tudo em conjunto, a probabilidade de que o tempo de resoluo seja superior a um tempo t
dado pela seguinte equao:
+ +
( > ) = (3.37)

Observe que a Equao 3.37 possui a forma de equao 3.24, em que T0 = (tswitch + tsetup + thold)/G e
= RC/(G-1). Em resumo, derivamos a Equao 3.24 e mostrmos como T0 e dependem das
propriedades fsicas do dispositivo biestvel.
3.6. PARALELISMO
A velocidade de um sistema caracterizada pela latncia e pela taxa de transferncia de informao
(throughput) em movimento atravs dela. Ns definimos um token como um grupo de entradas que so
processadas para produzir um grupo de sadas. A latncia de um sistema o tempo requerido para que
um token passe atravs do sistema desde o incio at ao fim. A taxa de transferncia de informao
determinada pelo nmero de tokens que podem ser processados por unidade de tempo.
Exemplo 3.15 BOLOS, TAXA DE TRANSFERNCIA DE INFORMAO E LATNCIA

Ben Bitdiddle est dando uma festa de leite e biscoitos para celebrar a instalao de seu controlador
de semforo. Ele leva 5 minutos para moldar os biscoitos e coloc-los na sua bandeja. Em seguida, so
precisos 15 minutos para que os biscoitos possam cozer no forno. Uma vez que os biscoitos estejam
cozidos, ele comea a preparar outra bandeja. Qual a taxa de transferncia e latncia de Ben para uma
bandeja de biscoitos?
208
Soluo: Neste exemplo, uma bandeja de biscoitos um token. A latncia de 1/3 hora por bandeja. A
taxa de transferncia de 3 bandejas / hora.
Como o leitor pode imaginar, o rendimento pode ser melhorado atravs do processamento de vrios
token em simultneo. Isso chamado de paralelismo, e vem em duas formas: espacial e temporal. Com
o paralelismo espacial, mltiplas cpias do hardware so fornecidas de modo que mltiplas tarefas
podem ser realizadas ao mesmo tempo. Com o paralelismo temporal, uma tarefa dividida em etapas,
como uma linha de montagem. Mltiplas tarefas podem ser distribudas atravs das etapas. Embora
cada tarefa deva passar por todas as etapas, uma tarefa diferente estar em cada etapa, num dado
instante, para que vrias tarefas se possam sobrepor. O paralelismo temporal normalmente chamado
de pipelining. O paralelismo espacial s vezes chamado apenas de paralelismo, mas vamos evitar essa
conveno de nomenclatura porque ambgua.
Exemplo 3.16 BISCOITOS E PARALELISMO

Ben Bitdiddle tem centenas de amigos que vm para a sua festa e precisa fazer biscoitos mais rpido.
Ele est a pensar em usar o paralelismo espacial e/ou temporal.
Paralelismo espacial: Ben pede a Alyssa P. Hacker para o ajudar. Ela tem a sua prpria bandeja de
biscoitos e forno.
Paralelismo Temporal: Ben recebe uma segunda bandeja de biscoitos. Uma vez que ele coloca uma
bandeja de biscoitos no forno, ele comea a moldar os biscoitos no outro tabuleiro, em vez de esperar
que a primeira bandeja coza.
Qual a taxa de transferncia e latncia usando paralelismo espacial? Usando paralelismo temporal?
Usando ambos?
Soluo: A latncia o tempo necessrio para concluir uma tarefa do incio at ao fim. Em todos os
casos, a latncia de 1/3 hora. Se Ben comea sem biscoito, a latncia o tempo necessrio para ele
produzir a primeira bandeja de biscoitos.
209
A taxa de transferncia o nmero de tabuleiros de biscoito por hora. Com o paralelismo

espacial, Ben e Alyssa cada um completa uma bandeja a cada 20 minutos. Assim, a taxa de
transferncia duplica, 6 bandejas/hora. Com o paralelismo temporal Ben coloca um novo tabuleiro
no forno a cada 15 minutos, alcanando uma taxa de transferncia de 4 bandejas/hora. Estas esto
ilustradas na Figura 3.57.
Se o Ben e a Alyssa usarem ambas as tcnicas, eles podem cozer 8 bandejas/hora.
Considere-se uma tarefa com latncia L. Num sistema sem paralelismo, a taxa de transferncia
de 1/L. Num sistema com espacialidade paralela com N cpias do hardware, a taxa de
transferncia de N/L. Num sistema temporalmente paralelo, a tarefa idealmente dividida em
N etapas, ou estgios, de igual comprimento. Em tal caso, a taxa de transferncia tambm N/L,
e apenas uma cpia do hardware requerida. No entanto, como o exemplo dos biscoitos
demostrou, encontrando N passos de igual comprimento muitas vezes impraticvel. Se o passo
mais longo tem uma latncia de L1, a taxa de transferncia do pipeline e de 1/L1.
Figura 3.57 Paralelismo espacial e temporal na cozinha dos biscoitos

210
O Pipelining (paralelismo temporal) particularmente atraente porque acelera um circuito sem

duplicar o hardware. Em vez disso, os registros so colocados entre os blocos de lgica combinatria para
dividir a lgica em etapas mais curtas que podem ser executadas com um relgio mais rpido. Os registros
evitam que um token num estgio do pipeline alcance outro token e o corrompa.
A Figura 3.58 apresenta um exemplo de um circuito sem paralelismo. Ele contm quatro blocos de
lgica entre os registros. O caminho crtico passa atravs de blocos 2, 3 e 4. Suponha que o registro tem
um atraso de propagao de 0,3 ns do relgio-para-Q e um tempo de configurao de 0,2 ns. Ento o
tempo de ciclo Tc = 0,3 + 3 + 2 + 4 + 0,2 = 9,5 ns. O circuito tem uma latncia de 9,5 ns e uma taxa de
transferncia de 1/9,5 ns = 105 MHz.
Figura 3.58 Circuito sem pipeline
Figura 3.59 Circuito com pipeline de dois estgios
211
Figura 3.60 Circuito com pipeline de trs estgios
A Figura 3.59 apresenta o mesmo circuito dividido por um pipeline de dois estgios atravs da adio
de um registro entre os blocos 3 e 4. A primeira fase tem um perodo de relgio mnimo de 0,3 + 3 + 2 +
0,2 = 5,5 ns. A segunda fase tem um perodo de relgio mnimo de 0,3 + 4 + 0.2 = 4.5 ns. O relgio deve
ser lento o suficiente para que todos os estgios possam trabalhar. Assim, Tc = 5,5 ns. A latncia de
dois ciclos de relgio, ou 11 ns. A taxa de transferncia de 1 / 5.5 ns = 182 MHz. Este exemplo mostra
que, num circuito real, usando um pipeline com dois estgios quase dobra a taxa de transferncia e
aumenta ligeiramente a latncia. Em comparao, um pipeline ideal permitiria exatamente o dobro da
taxa de transferncia, sem qualquer penalidade na latncia. A discrepncia acontece porque o circuito
no pode ser dividido em duas metades exatamente iguais e porque os registros introduzem mais
sobrecarga de sequenciamento.
A Figura 3.60 apresenta o mesmo circuito dividida num pipeline de trs estgios. Note-se que mais
dois registros so necessrios para armazenar os resultados dos blocos 1 e 2 no final do primeiro estgio
do pipeline. O tempo de ciclo agora limitado pelo terceiro estgio em 4,5 ns. A latncia de trs ciclos,
ou 13,5 ns. A taxa de transferncia de 1/4,5 ns = 222 MHz. Mais uma vez, a adio de um estgio do
pipeline melhora o rendimento custa de alguma latncia.
Embora estas tcnicas sejam poderosas, elas no se aplicam a todas as situaes. A desgraa do
paralelismo so as dependncias. Se a tarefa atual dependente do resultado de uma tarefa anterior,
ao invs de apenas os estgios anteriores da tarefa atual, a tarefa no pode comear at que a tarefa
anterior esteja concluda. Por exemplo, se o Ben quer verificar se a primeira bandeja de biscoitos tem
um sabor bom, antes que ele comece a preparar a segunda, ele tem uma dependncia que impede o
212
pipeline e a operao paralela. O paralelismo uma das tcnicas mais importantes para a concepo de
sistemas digitais de alto desempenho. O Captulo 7 discute a operao de pipeline e mostra exemplos de
como manipular as dependncias.
3.7. SUMRIO
Este Captulo descreveu a anlise e projeto de lgica sequencial. Em contraste com a lgica
combinatria, cujas sadas dependem apenas das entradas correntes, sadas lgicas sequenciais
dependem de ambas as entradas corrente e anteriores. Por outras palavras, a lgica sequencial memoriza
informaes sobre entradas anteriores. Esta memria chamada de estado da lgica.
Os circuitos sequenciais podem ser difceis de analisar e so fceis de desenhar incorretamente, por
Quem conseguisse inventar lgica
isso, limitamo-nos a um pequeno conjunto de blocos de construo cuidadosamente projetados. O
cujas sadas dependessem de entradas
elemento mais importante para os nossos propsitos o flip-flop, que recebe um relgio e uma entrada futuras seria fabulosamente rico!
D e produz uma sada Q. O flip-flop cpia D para Q no flanco ascendente do relgio e, de outra forma,
recorda-se do antigo estado de Q. Um grupo de flip-flops que partilham de um relgio geralmente
chamado de registro. Os flip-flops podem tambm receber sinais de controlo de reset ou enable.
Embora existam muitas formas de lgica sequencial, ns nos disciplinamos em usar circuitos
sequenciais sncronos, porque so fceis de projetar. Os circuitos sequenciais sncronos consistem em
blocos de lgica combinatria separados por registros operados por relgios. O estado do circuito
armazenado no registro e atualizado apenas nos flancos do relgio.
As mquinas de estados finitos so uma tcnica poderosa para projetar circuitos sequenciais. Para
projetar uma FSM, primeiro devemos identificar as entradas e as sadas da mquina e esboar um
diagrama de transio de estado, indicando os estados e as transies entre eles. Devemos selecionar
uma codificao para os estados, e reescrever o diagrama como uma tabela de transio de estado e
tabela de sada, indicando o prximo estado e de sada, dado o estado atual e as entradas. A partir dessas
tabelas, podemos projetar a lgica combinatria para determinar o prximo estado e a sada, e em
seguida podemos esboar o circuito.
213
Os circuitos sequenciais sncronos possuem especificaes temporais, incluindo o tempo de

propagao do relgio-para-Q e os contamination delays, tpcq e tccq, e o setup time e hold time, tsetup e
thold. Para uma operao correta, as suas entradas devem estar estveis durante um aperture time que
comea um setup time antes do flanco ascendente do relgio e termina um hold time aps o flanco
ascendente do relgio. O tempo de ciclo mnimo Tc do sistema igual ao atraso de propagao tpd atravs
da lgica combinatria mais tpcq + tsetup do registro. Para uma operao correta, o contamination delay
atravs do registro e da lgica de combinatria deve ser maior que thold. Apesar da concepo errada, o
hold time no afeta o tempo de ciclo.
O desempenho geral do sistema medido em latncia e taxa de transferncia. A latncia o tempo
necessrio para que um token passe do incio ao fim. A taxa de transferncia corresponde ao nmero de
tokens que o sistema pode processar por unidade de tempo. O paralelismo melhora a taxa de
transferncia do sistema.
214
Exerccios
Exerccio 3.1 Dadas as formas de onda mostradas na Figura 3.61, esboar a sada, Q, de uma bscula
SR.
Figura 3.61 Formas de onda de entrada da bscula SR para o Exerccio 3.1
Exerccio 3.2 Dadas as formas de onda mostradas na Figura 3.62, esboar a sada, Q, de uma bscula
SR.
Figura 3.62 Formas de onda de entrada de bscula SR para o Exerccio 3.2
Exerccio 3.3 Dadas as formas de onda mostradas na Figura 3.63, esboar a sada, Q, D de uma
bscula.
Figura 3.63 Formas de onda de entrada da bscula D ou flip-flop para os Exerccio 3.3 e Exerccio
3.5.
215
Exerccio 3.4 Dadas as formas de onda mostradas na Figura 3.64, esboar a sada, Q, de uma
bscula D.
Figura 3.64 Formas de onda da entrada de D da bscula ou flip-flop para os Exerccio 3.4 e
Exerccio 3.6
Exerccio 3.5 Tendo em conta as formas de onda mostradas na Figura 3.63, esboar a sada, Q, de
um flip-flop D.
Exerccio 3.6 Dadas as formas de onda mostradas na Figura 3.64, esboar a sada, Q, de um flip-
flop D.
Exerccio 3.7 O circuito na Figura 3.65 de lgica combinatria ou de lgica sequencial? Explicar
de uma forma simples, qual a relao entre as entradas e sadas. Como o leitor chamaria a este
circuito?
Figura 3.65 Circuito mistrio
216
Exerccio 3.8 O circuito na Figura 3.66 de lgica combinatria ou de lgica sequencial? Explicar de
uma forma simples, qual a relao entre as entradas e sadas. Como o leitor chamaria a este circuito?
Figura 3.66 Circuito mistrio
Exerccio 3.9 O flip-flop toogle (T) tem uma entrada, CLK, e uma sada, P. A cada flanco ascendente
do CLK, Q alterna com o complemento do seu valor anterior. Desenhe um esquema para um flip-flop T
usando um D flip-flop e um inversor.
Exerccio 3.10 Um flip-flop JK recebe um relgio e duas entradas, J e K. No flanco ascendente do

relgio, ele atualiza a sada, P. Se J e K so ambos 0, Q mantm o seu valor antigo. Se apenas J 1, Q
torna-se 1. Se apenas K 1, Q torna-se 0. Se ambos J e K so 1, Q torna-se o oposto do seu estado atual.
(a) Construa um flip-flop JK usando um flip-flop D e algumas combinaes lgica.
(b) Construa um flip-flop D usando um flip-flop JK e algumas combinaes lgica.
(c) Construir um flip-flop T (ver Exerccio 3.9) usando um flip-flop JK.
217
Exerccio 3.11 O circuito da Figura 3.67 chamado de elemento C-Muller. Explique que forma
simples qual a relao entre as entradas e sada.
Figura 3.67 Elemento-C de Muller
Exerccio 3.12 Projete uma bscula D resettable assncrona usando portas lgicas.
Exerccio 3.13 Projete um flip-flop D resettable assncrono usando portas lgicas.
Exerccio 3.14 Projete um flip-flop D settable sncrona configurvel usando portas lgicas.
Exerccio 3.15 Projete um flip-flop D settable assncrona usando portas lgicas.
Exerccio 3.16 Suponha que um oscilador em anel construdo a partir de N inversores ligados
num loop. Cada inversor tem um atraso mnimo de tcd e um atraso mximo de tpd. Se N mpar,
determine a gama de frequncias em que o oscilador pode operar.
Exerccio 3.17 Por que deve N ser impar no Exerccio 3.16?
218
Exerccio 3.18 Quais dos circuitos da Figura 3.68 so circuitos sequenciais sncronos? Explique.
Figura 3.68 Circuitos
Exerccio 3.19 O leitor est a projetar um controlador para um elevador de um edifcio de 25

andares. O controlador possui duas entradas: para cima e para baixo. Ele produz uma sada que indica
o andar que o elevador est ligado. No h piso 13. Qual o nmero mnimo de bits de estado do
controlador?
Exerccio 3.20 leitor est a projetar uma FSM para acompanhar o humor dos quatro estudantes que
trabalham no laboratrio de projeto digital. O humor de cada aluno ou HAPPY (o circuito funciona),
SAD (o circuito explodiu), BUSY (trabalhando no circuito), CLUELESS (confuso sobre o circuito), ou
ASLEEP (face para baixo na placa de circuito). Quantos estados tem a FSM? Qual o nmero mnimo
de bits necessrios para representar estes estados?
219
Exerccio 3.21 Como realizar o factoring da FSM do Exerccio 3.20 em vrias mquinas mais
simples? Quantos estados cada mquina mais simples tem? Qual o nmero mnimo total de bits
necessrios neste projeto?
Exerccio 3.22 Descreva por palavras o que faz a mquina de estado da Figura 3.69. Utilizando a
codificao binria de estado, complete uma tabela de transio de estado e uma tabela de sada
para a FSM. Escreva as equaes Booleanas para o prximo estado e de sada e esboce um esquema
da FSM.
Figura 3.69 Diagrama de transio de estados
Exerccio 3.23 Descreva por palavras suas o que faz a mquina de estado na Figura 3.70. Utilizando
a codificao de estado binrio, complete uma tabela de transio de estado e uma tabela de sada
para a FSM. Escreva as equaes Booleanas para o prximo estado e de sada e esboce um esquema
da FSM.
Figura 3.70 Diagrama de transio de estados
220
Exerccio 3.24 Os acidentes continuam a ocorrer no cruzamento da Avenida Acadmica e com o

Boulevard Bravado. A equipa de futebol corre para o cruzamento no momento em que a luz B fica
verde. Eles esto a chocar com os alunos de mestrado, privados de sono, que cambaleiam para o
cruzamento um pouco antes da luz A ficar vermelha. Estenda o controlador de semforo da Seo 3.4.1
para que ambas as luzes sejam vermelhas por 5 segundos antes de qualquer luz ficar verde novamente.
Esboce o seu melhorou diagrama de transio de estados da mquina de Moore, codificaes de
estados, tabela de transio de estado, tabela de sada, equaes de prximo estado e de sada, e o
esquema da sua FSM.
Exerccio 3.25 O caracol da Alyssa P. Hacker da Seo 3.4.3 tem uma filha cujo crebro uma
mquina de Mealy. A caracol filha sorri quando ela desliza sobre o padro de 1101 ou o padro 1110.
Esboce o diagrama de transio de estado para este caracol feliz usando o menor nmero de estados
possvel. Escolha uma codificao de estados e escreva uma tabela de transio de estado e de sada
combinada usando as suas codificaes. Escreva as equaes do prximo estado e de sada e esboce o
esquema da sua FSM.
Exerccio 3.26 O leitor foi convocado para projetar um distribuidor de mquina de refrigerante para
a sala do departamento. Os refrigerantes so parcialmente subsidiados pelo captulo estudante do IEEE,
pelo que custam apenas 25 centavos. A mquina aceita nqueis, moedas de dez centavos e quartos.
Quando forem inseridas moedas suficientes, ele dispensa o refrigerante e retorna o troco necessrio.
Projete um controlador FSM para a mquina de refrigerante. As entradas da FSM so Nickel, Dime, e
Quarter, indicando a moeda que foi inserido. Suponha que uma moeda inserida exatamente em cada
ciclo. As sadas so Dispense, Return Nickel, Return Dime, e ReturnTwoDimes. Quando a FSM chega a
25 centavos de dlar, ativa o dispensador e as sadas Return devolvem o troco necessrios. Em seguida,
ela deve estar pronta para comear a aceitar moedas para outro refrigerante.
221
Exerccio 3.27 O cdigo de Grey tem uma propriedade til na qual os nmeros consecutivos
diferem apenas num bit de posio. A Tabela 3.23 lista um cdigo de Gray de 3-bits que representa
os nmeros 0 a 7. Projete uma FSM de um contador de Gray de 3-bit mdulo 8 sem entradas e com
trs sadas. (Um contador mdulo N conta de 0 a N-1, repetidamente. Por exemplo, um relgio usa
um contador de mdulo 60 para os minutos e segundos que contam de 0 a 59.) Quando reiniciado,
a sada deve ser 000. Em cada ciclo de relgio, a sada deve avanar para o prximo cdigo de Gray.
Depois de atingir 100, deve repetir com 000.
Tabela 3.23 Cdigo de Gray de 3-bits
Exerccio 3.28 Estenda o seu contador de Gray mdulo 8 do Exerccio 3.27 para um contador
UP/DOWN, adicionando uma entrada UP. Se UP = 1, o contador avana para a prxima srie. Se UP
= 0, o contador recua para o nmero anterior.
222
Exerccio 3.29 A sua empresa, Detect-o-rama, gostaria de projetar uma FSM que leva duas
entradas, A e B, e gera uma sada, Z. A sada no ciclo n, Zn, ou o resultado booleano de AND ou OR
da correspondente entrada An e da entrada anterior An-1, dependendo a outra entrada, Bn:
= 1 = 0
= + 1 = 1
(a) Esboce a forma de onda para Z dadas as entradas mostrados na Figura 3.71.
(b) esta FSM uma mquina de Moore ou de Mealy?
(c) Projete a FSM. Mostre o seu diagrama de transio de estado, tabela de transio de estados
codificados, equaes de prximo estado e de sada, e esquemtico.
Figura 3.71 Formas de onda das entradas da FSM
Exerccio 3.30 Projete uma FSM com uma entrada, A, e duas sadas, X e Y. X deve ser 1 se A tiver
sido 1 por, pelo menos, durante trs ciclos (no necessariamente consecutivamente). Y deve ser 1 se
A tiver sido 1 por, pelo menos, dois ciclos consecutivos. Mostre o seu diagrama de transio de estado,
tabela de transio de estados codificados, equaes do prximo estado e de sada, e esquemtico.
Exerccio 3.31 Analise a FSM mostrada na Figura 3.72. Escreva as tabelas de transio de estados
e de sada e esboce o diagrama de transio de estado. Descrever em palavras o que a FSM faz.
223
Figura 3.72 Esquemtico da FSM
Exerccio 3.32 Repita o Exerccio 3.31 para a FSM mostrada na Figura 3.73. Lembre-se que as
entradas s e r do registro indicam ligada e desligada, respectivamente.
Figura 3.73 Esquemtico da FSM
Exerccio 3.33 Ben Bitdiddle projetou o circuito da Figura 3.74 para calcular uma funo com
registro XOR de quatro entradas. Cada porta XOR de duas entradas tem um atraso de propagao
de 100 ps e um contamination delay de 55 ps. Cada flip-flop tem um tempo de configurao de 60
ps, um hold time de 20 ps, um atraso mximo de relgio-para-Q de 70 ps, e um atraso mnimo de
relgio-para-Q de 50 ps.
(a) Se no houver nenhum skew do relgio, qual a frequncia mxima de funcionamento do
circuito?
(b) Quanto skew do relgio pode tolerar o circuito se deve operar a 2 GHz?
(c) Quanto skew do relgio pode tolerar o circuito antes que ele possa experimentar uma
violao do hold time?
(d) Alyssa P. Hacker observa que ela pode redesenhar a lgica combinatria entre os registros
para ser mais rpida e tolerar mais a skew do relgio. O seu circuito melhorado tambm utiliza trs
224
XOR de duas entradas, mas eles esto dispostos de forma diferente. Qual o seu circuito? Qual a sua
frequncia mxima, se no houver a skew do relgio? Quanto skew do relgio pode tolerar o circuito
antes que ele possa experimentar uma violao do hold time?
Figura 3.74 Circuito XOR de quatro entradas com registro
Exerccio 3.34 O leitor est a projetar um componente adicional para o extremamente rpido
processador RePentium 2-bits. O somador construdo a partir de dois full-adders tal que o transporte
para fora do primeiro somador o transporte para o segundo somador, como mostrado na Figura 3.75.
O seu somador tem registros de entrada e sada e deve completar a soma num ciclo de relgio. Cada
full-adder possui os seguintes atrasos de propagao: 20 ps de Cin para Cout ou para Sum (S), 25 ps de A
ou B para Cout, e 30 ps de A ou B para S. O somador tem um contamination delay de 15 ps da Cin para
qualquer sada e 22 ps de A ou B para qualquer sada. Cada flip-flop tem um setup time de 30 ps, um
hold time de 10 ps, um atraso de propagao relgio-para-Q de 35 ps, e um contamination delay do
relgio-para-Q de 21 ps.
(a) Se no houver nenhum skew do relgio, qual a frequncia mxima de funcionamento do
circuito?
(b) Quanto skew do relgio pode tolerar o circuito se ele deve operar a 8 GHz?
(c) Quanto skew do relgio pode tolerar o circuito antes que ela possa experimentar uma violao
hold time?
225
Figura 3.75 Esquemtico de um somador de 2-bits
Exerccio 3.35 Uma FPGA (Fields Programmable Gate Array) usa CLB (Configurable Logical
Blocks) em vez de portas lgicas para implementar a lgica combinatria. A FPGA da Xilinx Spartan
3 tem atrasos de propagao e contaminantion delay de 0,61 e 0,30 ns, respectivamente, para cada
CLB. Ela tambm contm flip-flops com atrasos de propagao e contaminantion delay de 0,72 e
0,50 ns, e setup time e hold time de 0,53 e 0 ns, respectivamente.
(a) Se o leitor est a construir um sistema que precisa operar a 40 MHz, quantos CLB consecutivos
pode usar entre dois flip-flops? Suponha que no h nenhum skew do relgio e nenhum atraso
atravs dos condutores entre CLB.
(b) Suponha que todos os caminhos entre flip-flops passam por pelo menos um CLB. Quanto
skew do relgio pode o FPGA ter sem violar o hold time?
Exerccio 3.36 Um sincronizador construdo a partir de um par de flip-flops com tsetup = 50 ps,
T0 = 20 ps, e = 30 ps. Amostra uma entrada assncrona que muda 108 vezes por segundo. Qual o
perodo mnimo de relgio do sincronizador para alcanar um tempo mdio entre falhas (MTBF) de
100 anos?
226
Exerccio 3.37 O leitor gostaria de construir um sincronizador que pode receber entradas
assncronas com um MTBF de 50 anos. O sistema opera a 1 GHz, e so utilizados flip-flops com
amostragem = 100 ps, T0 = 110 ps, e tsetup = 70 ps. O sincronizador recebe uma nova entrada assncrona
em mdia 0,5 vezes por segundo (isto , uma vez a cada 2 segundos). Qual a probabilidade de falha
requerida no cumprimento desta MTBF? Quantos ciclos de relgio seriam necessrios esperar antes
de ler o sinal de entrada amostrado para obter essa probabilidade de erro?
Exerccio 3.38 O leitor est andando pelo corredor quando voc encontra o seu parceiro de
laboratrio caminhando em outra direo. Os dois do um primeiro passo para um lado e ainda assim
esto no caminho um do outro. Ento ambos do um passo para o outro lado e continuam no caminho
um do outro. Em seguida, ambos esperam um pouco, na expectativa de que a outra pessoa d um
passo para se afastar. O leitor pode modelar esta situao como um ponto metaestvel e aplicar a
mesma teoria que tem sido aplicado a sincronizadores e flip-flops. Suponha que criar um modelo
matemtico para si e para o seu parceiro de laboratrio. Comea o infeliz encontro no estado

metaestvel. A probabilidade de que voc permanecer nesse estado aps t segundos . Em que
indica a sua taxa de resposta; Hoje, o seu crebro foi afetado pela falta de sono e tem = 20 segundos.
(a) Quanto tempo passar at que o leitor tenha 99% de certeza de que vai sair da metaestabilidade
(i.e., Descobrir como passar um ao outro)?
(b) O leitor no est apenas sonolento, mas tambm com uma fome voraz. Na verdade, vai morrer
de fome se no comear a ir para o refeitrio dentro de 3 minutos. Qual a probabilidade de que o
seu parceiro de laboratrio tenha que o arrastar at morgue?
Exerccio 3.39 O leitor construiu um sincronizador usando flip-flops com T0 = 20 ps e = 30 ps. O seu
chefe diz-lhe que vai ser preciso aumentar o MTBF por um fator de 10. De quanto ser preciso
incrementar o perodo de relgio?
227
Exerccio 3.40 Ben Bitdiddle inventa o sincronizador novo e melhorado da Figura 3.76 que afirma
eliminar a metaestabilidade num nico ciclo. Ele explica que o circuito na caixa M um detector
analgico de metaestabilidade que produz uma sada de tenso HIGH se a entrada est na zona
proibida entre VIL e VIH. O detector de metaestabilidade verifica para determinar se o primeiro flip-
flop produziu uma sada metaestvel em D2. Se assim for, realizada um reset assncrono do flip-flop
para produzir um 0 bom em D2. O segundo flip-flop, em seguida, amostra D2, produzindo sempre
um nvel lgico vlido em Q. Alyssa P. Hacker diz a Ben que deve haver um erro no circuito, porque
eliminar a metaestabilidade to impossvel quanto a construo de uma mquina de movimento
perptuo. Quem est certo? Explique, mostrando o erro de Ben ou mostrando porque que a Alyssa
est errada.
Figura 3.76 Sincronizador novo e melhorado
228
Questes de entrevista
Os exerccios seguintes apresentam perguntas que foram feitas em entrevistas para trabalhos de
projeto digital.
Pergunta 3.1 Desenhar uma mquina de estados que poderia detectar quando ela recebesse a
sequncia srie 01010 na entrada.
Pergunta 3.2 Projete uma FSM srie (um bit por vez) complementar com duas entradas, Start e A,
e uma sada, Q. Um nmero binrio de comprimento arbitrrio fornecido na entrada A, comeando
com o bit menos significativo. O bit correspondente da sada aparece em Q no mesmo ciclo. Start
cativado num ciclo para inicializar a FSM antes do bit menos significativo ser fornecido.
Pergunta 3.3 Qual a diferena entre uma bscula e um flip-flop? Em que circunstncias prefervel
cada um?
Pergunta 3.4 desenhe um contador de 5-bits finito com uma mquina de estados.
Pergunta 3.5 Projete um circuito detector de flanco. A sada deve ir a HIGH um ciclo aps a entrada
fazer uma transio 0 1.
Pergunta 3.6 Descreva o conceito de pipelining e por que ele usado.
229
Pergunta 3.7 Descreva o que significa para um flip-flop ter um hold time negativo.
Pergunta 3.8 Dado sinal A, mostrado na Figura 3.77, projete um circuito que produza sinal B.
Figura 3.77 Formas de onda dos sinais
Pergunta 3.9 Considere um bloco de lgica entre dois registros. Explicar as restries de tempo.
Se for adicionado um buffer na entrada do relgio do receptor (o segundo flip-flop), a restrio de
setup time ficar melhor ou pior?
230
4. Linguagens de Descrio de
Hardware
4.1. INTRODUO
At agora, temos focado o projeto de circuitos digitais combinatrios ou sequenciais a nvel de diagramas
esquemticos. O processo de encontrar um conjunto eficiente de portas lgicas para realizar uma dada
funo trabalhoso e propenso a erros, uma vez que so necessrias simplificaes manuais de tabelas
verdade ou de equaes Booleanas, e traduo manual de mquinas de estado finitos em portas. Na dcada
de 90, os projetistas descobriram que eram muito mais produtivos se trabalhassem num nvel maior de
abstrao, especificando apenas a funo lgica e permitindo que uma ferramenta de projeto auxiliado por
computador (CAD - computer-aided design) produzisse as portas otimizadas. As especificaes so, de modo
geral, dadas numa linguagem de descrio de hardware (HDL hardware descriprion language). As duas
principais linguagens de descrio de hardware so a SystemVerilog e a VHDL.
A SystemVerilog e VHDL so construdas sobre princpios similares, mas possuem sintaxes diferentes. As
discusses destas linguagens neste Captulo so divididas em duas colunas, para comparao literal lado a
lado, com a SystemVerilog esquerda e a VHDL direita. Quando ler este Captulo pela primeira vez, foque
numa linguagem ou outra. Uma vez que conhea alguma, voc poder rapidamente aprender a outra, caso
precise.
Os Captulos subsequentes mostram o hardware tanto na forma esquemtica quanto na forma HDL. Se
voc optar por pular este Captulo e no aprender uma das HDL, voc ainda ser capaz de dominar os
231
Captulo quatro Linguagens de Descrio de Hardware
princpios da organizao computacional dos esquemticos. No entanto, a grande maioria dos sistemas
comerciais atualmente so construindos utilizando-se HDL ao invs de esquemticos. Se voc pretende
ser um projetista de sistemas digitais em qualquer ponto de sua carreira profissional, ser aconselhado a
aprender uma das HDL.
4.1.1. Mdulos
Um bloco de hardware com entradas e sadas chamado de mdulo. Uma porta AND, um
multiplexador, e um circuito de prioridade so todos exemplos de mdulos de hardware. Os dois estilos
gerais para a descrio da funcionalidade do mdulo so a comportamental e a estrutural. Modelos
comportamentais descrevem o que o mdulo faz. Modelos estruturais descrevem como o mdulo
construdo a partir de partes simples; uma aplicao de hierarquia. O cdigo SystemVerilog e VHDL no
Exemplo HDL 4.1 ilustram as descries comportamentais de um mdulo que determina a funo lgica
do exemplo 2.6, = + + . Em ambas as linguagens, o mdulo chamado
sillyfuction e tem trs entradas, a, b e c, e uma sada, y.
Exemplo HDL 4.1 LGICA COMBINATRIA
SystemVerilog VHDL
Module sillyfunction(input logic a, b, c, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic y);
assign = ~a & ~b ~c | entity sillyfunction is
a & ~b ~c | port(a, b, c: in STD_LOGIC;
a & ~b c; y: out STD_LOGIC);
endmodule end;
architecture synth of sillyfunction is

begin
y <= (not a and not b and not c) or
(a and not b and not c) or
(a and not b and c);
end;
232
Um mdulo SystemVerilog comea com o nome do mdulo e uma O cdigo VHDL possui trs partes: a clusula library use, a
lista de entradas e sadas. A declarao assign descreve a lgica declarao entity e o corpo architecture. A clusula
combinatria. ~ indica NOT, & indica AND e | indica OR. library use ser discutida na seo 4.7.2. a declarao entity
Sinais do tipo logic, tais como entradas e sadas, so variveis lista o nome do mdulo e as suas entradas e sadas. O corpo
Boolenanas (0 ou 1). Eles tambm podem ter valores flutuantes e architecture define o que o mdulo faz.
indefinidos, com discutido na seo 4.2.8. Os sinais VHDL, tais como entradas e sadas, devem ter uma
O tipo logic foi introduzido em SystemVerilog. Ele substitui o tipo declarao de tipo. Sinais digitais devem ser declarados como sendo
reg, o qual era uma permanente fonte de confuso no Verilog. do tipo STD_LOGIC. Sinais do tipo STD_LOGIC podem ter valores
logic deveria ser utilizado sempre, exceto em sinais com mltiplos 0 ou 1, assim como valores indefinidos e flutuantes que sero
drivers. Sinais com mltiplos drivers so chamados de nets e so descritos na seo 4.2.8. O tipo STD_LOGIC definido na biblioteca
explicados na seo 4.7. IEEE.STD_LOGIC_1164, e por isso que essa biblioteca deve ser
utilizada.
A VHDL necessita de uma boa ordem padro de operaes entre
AND e OR, por isso, equaes Booleanas devem estar entre
parnteses.
Um mdulo, como o leitor poderia esperar, uma boa aplicao de modularidade. Ele tem numa
interface bem definida, consistindo em entradas e sadas, e realiza uma funo. O modo particular no
qual ele codificado no importante para os outros que podem utilizar esse cdigo, contanto que ele
execute a sua funo.
4.1.2. Origens das Linguagens O termo bug data da inveno do
computador. Thomas Edison
As universidades esto quase igualmente divididas sobre qual dessas linguagens ser apresentada
chamava de bugs as pequenas falhas
num primeiro curso. A indstria est tendendo para o SystemVerilog, mas muitas companhias continuam
e dificuldades em suas invenes em
utilizando o VHDL e muitos projetistas precisam ser fluentes em ambas. 1878.
Comparada SystemVerilog, a VHDL mais prolixa e trabalhosa, como o leitor poderia esperar de
uma linguagem desenvolvida por um comit.
233
SystemVerilog VHDL
A Verilog foi desenvolvida pela Gateway Design Automation como A linguagem VHDL um acrnimo para VHSIC Hardware
uma linguagem proprietria para simulaes lgicas em 1984. A Description Language. A VHSIC por sua vez, um acrnimo para o
Gateway foi adquirida pela Cadence em 1989 e a Verilog se tornou um programa Very High Speed Integrated Circuits do Departamento de
padro aberto em 1990, sob o controle da Open Verilog International. Defesa dos EUA.
A linguagem se tornou um padro IEEE em 1995. A linguagem foi A VHDL foi originalmente desenvolvida em 1981 pelo
estendida em 1995 para simplificar idiossincrasias e para melhor Departamento de Defesa para descrever estruturas e funes de
suportar a modelagem e a verificao de sistemas. Essas extenses hardware. Foi baseado na linguagem de programao Ada. A
foram fundidas num padro nico de linguagem, o qual agora linguagem foi inicialmente imaginada para documentao, mas foi
chamado de SystemVerilog (IEEE STD 1800-2009). Os nomes de rapidamente adotada para simulao e sntese. O IEEE a padronizou
arquivos em SystemVerilog normalmente terminam em .sv. em 1987 e atualizou o padro muitas vezes desde ento. Este Captulo
baseado na reviso de 2008 do padro VHDL (IEEE STD 1076-2008),
o que agiliza a linguagem em vrios modos. Na hora da escrita, nem
todas as caractersticas do VHDL 2008 so suportadas pelas
ferramentas CAD; este Captulo usa apenas aquelas entendidas pelo
Synplicity, Altera Quartus e ModelSim. Os arquivos VHDL tm os seus
nomes normalmente terminados em .vhd.
Ambas as linguagens so totalmente capazes de descrever qualquer sistema de hardware, e ambas

possuem as suas peculiaridades. A melhor linguagem para se usar aquela em uso no seu local de
trabalho ou aquela que os seus clientes exigem. A maioria das ferramentas CAD hoje em dia permitem
que as duas linguagens sejam misturas, de modo que diferentes mdulos possam ser descritos em
linguagens diferentes.
234
4.1.3. Simulao e Sntese

Os dois maiores propsitos das HDL so a simulao e a sntese lgicas. Durante a simulao, as
entradas so aplicadas ao mdulo, e as sadas so examinadas para verificar se o mdulo opera
corretamente. Durante a sntese, a descrio textual do mdulo transformada em portas lgicas.
O termo "bug" anterior inveno
Simulao do computador. Thomas Edison
Os humanos rotineiramente cometem erros. Tais erros em projetos de hardware so chamados de chamava de "bugs" em 1878 as
"pequenas falhas e dificuldades" das
bugs. Eliminar os bugs de um sistema digital , obviamente, importante, especialmente quando os clientes
suas invenes.
esto pagando dinheiro e h vidas que dependem da correta operao. Testar um sistema no laboratrio
algo demorado. Descobrir a causa dos erros no laboratrio pode ser extremamente difcil, pois apenas O primeiro bug real de computador
sinais encaminhados para o chip podem ser observados. No existe um modo para diretamente observar foi uma mariposa descoberta entre os
o que est acontecendo dentro de um chip. Corrigir erros aps a construo do sistema pode ser rels do computador eletromecnico
devastadoramente caro. Por exemplo, corrigir um erro num circuito integrado topo de gama custa mais Harvard Mark II em 1947. Ela foi
encontrada por Grace Hopper, que
de um milho de dlares e leva muitos meses. Um bug infame foi o FDIV (diviso em vrgula flutuante)
registrou o incidente, comentando:
num processador Pentium, da Intel, que forcou a companhia a substituir os chips aps eles terem sido
o primeiro caso verdadeiro de um
despachados, com um custo total de U$ 475 milhes. A simulao lgica essencial para testar um sistema bug sendo encontrado.
antes de que ele seja construdo.
A Figura 4.1 mostra as formas de onda para uma simulao do mdulo sillyfunction anterior,
demonstrando que o mdulo funciona corretamente. y TRUE quando a, b e c so 000, 100 e 101,
como especificado na equao Booleana.
Figura 4.1 Formas de onda de simulao
235
Sntese
A sntese lgica transforma o cdigo HDL numa netlist descrevendo o hardware (isto , as portas lgicas
e os fios que as conectam). O sintetizador lgico pode realizar otimizaes para reduzir a quantidade de
hardware necessrio. A netlist pode ser um arquivo de texto, ou pode ser desenhada como um esquemtico
para ajudar a visualizar o circuito. A Figura 4.2 mostra o resultado da sntese do mdulo sillyfunction.
Note como os trs AND de trs entradas so simplificados como dois AND de duas entradas, como
mostrado por ns no exemplo 2.6 utilizando lgebra Booleana.
Figura 4.2 Circuito Sintetizado
A descrio de circuitos em HDL lembra os cdigos de uma linguagem de programao. No entanto, voc
deve se lembrar que o cdigo projetado para representar hardware. SystemVerilog e VHDL so linguagens
ricas com muitos comandos. Nem todos esses comandos podem ser sintetizados em hardware. Por
exemplo, um comando para imprimir resultados na tela durante uma simulao no pode ser traduzido em
hardware. Devido ao nosso principal interesse ser construir hardware, ns iremos enfatizar um
subconjunto sintetizvel das linguagens. Especificamente, iremos dividir o cdigo HDL em mdulos
sintetizveis e de testes. Os mdulos sintetizveis descrevem o hardware. Os cdigos de teste contm
entradas para aplicar num mdulo, para verificar quando os resultados na sada esto corretos, e imprimir
discrepncias entre sadas reais e esperadas. O cdigo de teste tem a inteno apenas de simulao e no
pode ser sintetizado.
Um dos erros mais comuns dos iniciantes pensar em HDL como sendo um programa de computador
ao invs de uma abreviao para descrever hardware digital. Se voc no sabe aproximadamente que
236
hardware deve ser sintetizado, voc provavelmente no gostar do que ir conseguir. O leitor pode criar
muito mais hardware do que o necessrio, ou ento escrever cdigos que so simulados corretamente,
mas no podem ser implementados em hardware. Ao invs disso, pense no seu sistema em termos de
blocos combinatrios, registradores e mquinas de estados finitos. Esboce esses blocos num papel e ento
mostre como eles so conectados, antes de comear a escrever o cdigo.
Atravs da nossa experincia, o melhor modo de aprender uma HDL atravs de exemplos. As HDL
possuem meios especficos de descrever vrias classes de lgica; esses modos so chamados de idiomas.
Este Captulo vai ensin-lo a como escrever o idioma HDL adequado para cada tipo de bloco e, em seguida,
como reunir esses blocos para produzir um sistema funcional. Quando o leitor precisar descrever um tipo
particular de hardware, procure por um exemplo similar e adapte-o para o seu propsito. No nos
atentaremos a definir rigorosamente a sintaxe das HDL, pois isso mortalmente tedioso e porque isso
tende a encorajar o pensamento das HDL como linguagens de programao, e no abreviaes para
hardware. As especificaes da IEEE SystemVerilog e da VHDL, e os seus manuais exaustivos e resumidos,
contm todos os detalhes, se o leitor necessitar de mais informao num tpico particular (Veja a seo
de leituras complementares no final deste livro).
4.2. LGICA COMBINATRIA

Lembre-se que ns estamos nos disciplinando para projetar circuitos sequenciais sncronos, os quais
consistem de lgica combinatria e registradores. As sadas da lgica combinatria dependem apenas das
entradas atuais. Esta seo descreve como escrever modelos comportamentais de lgica combinatria
utilizando-se HDL.
4.2.1. Operadores Bit a Bit
Operadores bit a bit agem em sinais de bits individuais ou em barramentos multi-bit. Por exemplo, o
mdulo inv, no Exemplo HDL 4.2, descreve quatro inversores conectados a barramentos de 4-bits.
237
Exemplo HDL 4.2 INVERSORES
SystemVerilog VHDL
module inv(input logic[3:0] a. library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic[3:0] y);
entity inv is
assign y=~a port(a: in STD_LOGIC_VECTOR(3 downto 0);
endmodule y: out STD_LOGIC_VECTOR(3 downto 0));
a[3:0] representa um barramento de 4-bits. Os bits, do mais end;

significativo para o menos significativo, so a[3], a[2], a[1]
e a[0]. Essa a chamada ordem de little-endian, devido ao bit architecture synth of inv is
menos significativo ter o menor nmero de bit. Ns poderamos ter begin
t <= not a;
nomeado o barramento a[4:1], caso em que a[4] seria o mais
end;
significativo. Ou ento poderamos ter usado a[0:3], em cujo caso
os bits, do mais significativo para o menos significativo, seriam VHDL utiliza STD_LOGIC_VECTOR para indicar os barramentos de
a[0], a[1], a[2] e a[3]. Isto chamado big endian order. STD.LOGIC. STD_LOGIC_VECTOR(3 downto 0) representa
um barramento de 4-bits. Os bits, do mais significativo para o menos
significativo, so a(3), a(2), a(1) e a(0). Esta a chamada
little endian, pois o bit menos significativo tem o menor nmero. Ns
poderamos ter declarado o barramento como
STD_LOGIC_VECTOR(4 downto 1), caso em que o bit 4 seria o
mais significativo. Ou ns poderamos ter escrito
STD_LOGIC_VECTOR(0 to 3), caso em que os bits, do mais
significativo para o menos significativo, seriam a(0), a(1), a(2)
e a(3). Esta a chamada ordem big-endian.
238
Figura 4.3 Circuito inv sintetizado
A ordenao de um barramento puramente arbitrria. De fato, a ordenao tambm irrelevante

para este exemplo, pois num banco de inversores no interessa qual a ordem em que os bits esto. A
ordenao apenas interessa para os operadores, tais como adio, onde a soma de uma coluna se
transporta para a prxima. Qualquer ordenao aceitvel, desde que utilizada consistentemente.
Iremos, consistentemente, utilizar a ordem little-endian, [N-1:0] em SystemVerilog e (N-1 downto
0) em VHDL, para um barramento de N-bits.
Aps cada cdigo de exemplo neste Captulo, um esquemtico produzido a partir do cdigo
SystemVerilog atravs da ferramenta de sntese Synplify Premier. A Figura 4.3 mostra que o mdulo inv
sintetiza um banco de quatro inversores conectados a barramentos de entrada e sada de 4-bits. Um
hardware similar produzido a partir do cdigo VHDL sintetizado.
O mdulo gates no Exemplo HDL 4.3 demonstra operaes bit a bit em barramentos de 4-bits para
outras funes lgicas bsicas.
Exemplo HDL 4.3 PORTAS LGICAS
SystemVerilog VHDL
module gates(input logic [3:0] a, b, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [3:0] y1, y2,
y3, y4, y5); entity gates is
port(a, b: in STD_LOGIC_VECTOR(3 downto 0);
/* five different two-input logic y1, y2, y3, y4,
gates acting on 4-bit busses */ y5: out STD_LOGIC_VECTOR(3 downto 0));
end;
239
assign y1 = a & b; // AND architecture synth of gates is

assign y2 = a | b; // OR begin
assign y3 = a ^ b; // XOR five different two-input logic gates
assign y4 = ~(a & b); // NAND acting on 4-bit busses
assign y5 = ~(a | b); // NOR y1 <= a and b;
endmodule y2 <= a or b;
y3 <= a xor b;
~, ^ e | so exemplos de operadores SystemVerilog, onde a, b, e y4 <= a nand b;
y1 so operandos. Uma combinao de operadores e operandos, y5 <= a nor b;
como por exemplo a&b, ou ~(a|b), chamada de expresso. Um end;
comando completo, como assign y4 = ~(a&b); chamado
declarao. not, xor e or so exemplos de operadores VHDL, onde a, b,
assign out = in1 op in2 chamado de declarao de e y1 so operandos. Uma combinao de operadores e operandos,
atribuio contnua. Atribuies contnuas terminam com um ponto e como a and b, ou a nor b, chamada de expresso. Um comando
vrgula. A qualquer momento que as entradas do lado direito de = completo, como y4 <= a nand b; chamado de declarao.
numa declarao de atribuio contnua mudam, a sada do lado out <= in1 op in2; chamado de declarao de atribuio
esquerdo recalculada. Desta maneira, declaraes de atribuies de sinal concorrente. Declaraes de atribuies VHDL terminam com
contnuas descrevem lgica combinatria. um ponto e vrgula. A qualquer momento que as entradas do lado
direito de <= numa declarao de atribuio de sinal concorrente
muda, a sada ao lado esquerdo recalculada. Dessa maneira,
declaraes de atribuio de sinais concorrentes descrevem lgica
combinatria.
240
Figura 4.4 Circuito gates sintetizado
4.2.2. Comentrios e Espaos em Branco

O exemplo das portas mostrou como formatar comentrios. SystemVerilog e VHDL no so exigentes
em relao ao uso de espaos em branco (isto , espaos, tabs e quebras de linha). Mesmo assim, uma
indentao apropriada e o uso de linhas em branco so teis para tornar projetos no triviais mais legveis.
Seja consistente no uso de capitalizao e underscores nos nomes dos mdulos e dos sinais. Este texto
utiliza sempre letras minsculas. Nomes de sinais e de mdulos no devem comear com um dgito.
SystemVerilog VHDL
Os comentrios em SystemVerilog so iguais aos do C ou Java. Comentrios que se iniciam com /* continuam, possivelmente atravs
Comentrios que iniciam com /* continuaro possivelmente atravs de mltiplas linhas, at o prximo */. Comentrios que se iniciam com
de muitas linhas, at o prximo */. Comentrios iniciando com // - - continuam at o fim da mesma linha.
continuam at o final da mesma linha. VHDL no case sensitive. y1 e Y1 so os mesmos sinais em VHDL.
No entanto, outras ferramentas que podem ler o seu arquivo podem
241
SystemVerilog case-sensitive. y1 e Y1 so sinais diferentes em ser case sensitive, levando a bugs desagradveis se voc,
SystemVerilog. No entanto, confuso utilizar mltiplos sinais que despreocupadamente, misturar letras maisculas e minsculas.
diferem apenas entre maisculas e minsculas.
4.2.3. Operadores de Reduo

Operadores de reduo implicam numa porta de mltiplas entradas atuando sobre um nico
barramento. O Exemplo HDL 4.1 descreve uma porta AND de oito entradas, a7, a6, ..., a0. Operadores
de reduo anlogos existem para portas OR, XOR, NAND, NOR e XNOR. Lembre-se que uma porta XOR
de mltiplas entradas realiza paridade, retornando TRUE se um nmero mpar de entradas TRUE.
Exemplo HDL 4.4 AND DE OITO ENTRADAS
SystemVerilog VHDL
module and8(input logic [7:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic y);
entity and8 is
assign y = &a; port(a: in STD_LOGIC_VECTOR(7 downto 0);
y: out STD_LOGIC);
// &a is much easier to write than end;
// assign y = a[7] & a[6] & a[5] & a[4] &
// a[3] & a[2] & a[1] & a[0]; architecture synth of and8 is
endmodule begin
y <= and a;
and a is much easier to write than
y <= a(7) and a(6) and a(5) and a(4) and
a(3) and a(2) and a(1) and a(0);
end;
242
Figura 4.5 Circuito and8 sintetizado
4.2.4. Atribuio Condicional

Atribuies condicionais selecionam a sada dentre alternativas baseadas numa entrada denominada
condio. O Exemplo HDL 4.5 ilustra um multiplexador 2:1 utilizando atribuio condicional.
Exemplo HDL 4.5 MULTIPLEXADOR 2:1
SystemVerilog VHDL
O operador condicional ?: escolhe, baseado numa primeira As atribuies condicionais de sinais realizam diferentes operaes,
expresso, entre a segunda e a terceira expresso. A primeira dependendo da condio. Elas so especialmente teis para se
expresso denominada condio. Se a condio 1, o operador descrever um multiplexador. Por exemplo, um multiplexador 2:1 pode
escolhe a segunda expresso. Se a condio 0, o operador escolhe a utilizar a atribuio condicional de sinais para selecionar uma de duas
terceira expresso. entradas de 4-bits.
?: especialmente til para descrever um multiplexador, pois,
baseado na primeira entrada, ele seleciona entre duas outras. O library IEEE; use IEEE.STD_LOGIC_1164.all;
cdigo abaixo demostra a linguagem para um multiplexador 2:1 com
entradas e sadas de 4-bits utilizando-se o operador condicional. entity mux2 is
port(d0, d1: in STD_LOGIC_VECTOR(3 downto 0);
s: in STD_LOGIC;
y: out STD_LOGIC_VECTOR(3 downto 0));
243
module mux2(input logic [3:0] d0, d1, end;

input logic s,
output logic [3:0] y); architecture synth of mux2 is
begin
assign y = s ? d1 : d0; y <= d1 when s else d0;
endmodule end;
Se s 1, ento y = d1. Se s 0, ento y = d0. A atribuio condicional de sinal define y como d1 se s 1. De outra
?: tambm chamado operador ternrio, pois recebe trs forma, define y como d0. Note que antes da reviso de 2008 da VHDL,
entradas. Ele utilizado com o mesmo propsito nas linguagens de tnhamos que escrever when s = 1 ao invs de when s.
programao C e Java.
Figura 4.6 Circuito mux2 sintetizado
O Exemplo HDL 4.6 mostra um multiplexador 4:1 baseado no mesmo princpio do multiplexador 2:1
do Exemplo HDL 4.5. A Figura 4.7 mostra o esquemtico produzido pelo Sinplify Premier, para o
multiplexador 4:1. Os softwares usam um smbolo diferente para o multiplexador do que o que este
texto tem mostrado at agora. O multiplexador possui mltiplos dados (d) e uma entrada de ativao
(e). Quando uma das entradas de ativao acionada, o dado associado passa para a sada. Por exemplo,
quando s[1] = s[0] = 0, a porta AND de baixo, un1_s_5, produz um 1, ativando a entrada de
baixo do multiplexador e o fazendo selecionar d0[3:0].
244
Exemplo HDL 4.6 MULTIPLEXADOR 4:1
SystemVerilog VHDL
Um multiplexador 4:1 pode selecionar uma de quatro entradas Um multiplexador pode selecionar uma de quatro entradas utilizando
utilizando operadores condicionais aninhados. mltiplas clusulas else na atribuio condicional de sinais.
module mux4(input logic [3:0] d0, d1, d2, d3, library IEEE; use IEEE.STD_LOGIC_1164.all;
input logic [1:0] s,
output logic [3:0] y); entity mux4 is
port(d0, d1,
assign y = s[1] ? (s[0] ? d3 : d2) d2, d3: in STD_LOGIC_VECTOR(3 downto 0);
: (s[0] ? d1 : d0); s: in STD_LOGIC_VECTOR(1 downto 0);
end;
Se s[1] 1, ento o multiplexador escolhe a primeira expresso
(s[0] ? d3: d2). Essa expresso, por sua vez, escolhe d3 ou architecture synth1 of mux4 is
d2 baseado em s[0] (y = d3 se s[0] 1 e d2 se s[0] 0). Se begin
s[1] 0, ento o multiplexador similarmente escolhe a segunda y <= d0 when s = "00" else
d1 when s = "01" else
expresso, a qual transmite, por sua vez, d1 ou d0, baseado em
d2 when s = "10" else
s[0]. d3;
end;
VHDL tambm suporta declaraes de atribuio de sinais

selecionados, possibilitando assim uma abreviao quando so
selecionadas uma ou mais possibilidades. Estas declaraes so
anlogas s declaraes switch/case ao invs de mltiplos if/else em
algumas linguagens de programao. O multiplexador 4:1 pode ser
reescrito com atribuio de sinais selecionados, como abaixo:
245
architecture synth2 of mux4 is

begin
with s select y <=
d0 when "00",
d1 when "01",
d2 when "10",
d3 when others;
end;
246
4.2.5. Variveis Internas

Muitas vezes conveniente quebrar uma funo complexa em passos intermedirios. Por exemplo,
um full adder, o qual ser discutido na Seo 5.2.1, um circuito com trs entradas e duas sadas
definido pelas seguintes equaes:
= (4.1)
= + + (4.2)
Se definirmos sinais intermedirios, P e G,
= (4.3)
= (4.4)
Podemos reescrever o somador completo da maneira como se segue:
= (4.6)
= + (4.7)
e so chamadas variveis internas, devido ao fato de elas no serem nem entradas nem sadas,
mas apenas serem utilizadas internamente no mdulo. Elas so similares s variveis locais nas
linguagens de programao. O Exemplo HDL 4.7 mostra como elas so utilizadas em HDL.
A declarao de atribuio em HDL (assign em SystemVerilog e <= em VHDL) ocorrem

simultaneamente. Isso diferente nas linguagens de programao convencionais, em que as
declaraes so avaliadas medida que so escritas. Numa linguagem convencional, importante que
= venha depois de = , pois as declaraes so executadas sequencialmente. Em
HDL, a ordem no importa. Assim como no hardware, as declaraes de atribuio so executadas a
qualquer momento que as entradas, os sinais do lado direito, modificam seu valor, independente da
ordem em que as declaraes de atribuio aparecem no mdulo.
247
Exemplo HDL 4.7 SOMADOR COMPLETO
SystemVerilog VHDL
Em SystemVerilog, os sinais internos so normalmente declarados Em VHDL, sinais so usados para representar variveis interna, cujos
como logic. valores so definidos por declaraes de atribuio de sinais
concorrentes, como p <= a xor b;
module fulladder(input logic a, b, cin,
output logic s, cout); library IEEE; use IEEE.STD_LOGIC_1164.all;
logic p, g; entity fulladder is
port(a, b, cin: in STD_LOGIC;
assign p = a ^ b; s, cout: out STD_LOGIC);
assign g = a & b; end;
assign s = p ^ cin; architecture synth of fulladder is

assign cout = g | (p & cin); signal p, g: STD_LOGIC;
endmodule begin
p <= a xor b;
g <= a and b;
s <= p xor cin;
cout <= g or (p and cin);
end;
Figura 4.8 Circuito full adder sintetizado

248
4.2.6. Precedncia
Note que ns colocamos entre parnteses a expresso cout no Exemplo HDL 4.7, para definir a
ordem das operaes, como = + (. ), ao invs de = ( + ). . Se ns no tivssemos
utilizado parnteses, a ordem padro de operao seria definida pela linguagem. O Exemplo HDL 4.8
especifica a precedncia do operador, da maior para a menor, para cada linguagem. A tabela inclui
operadores aritmticos de deslocamento e de comparao que sero definidos no Captulo 5.
Exemplo HDL 4.8 OPERADOR PRECEDNCIA
SystemVerilog VHDL
Tabela 4.1 Precedncia de operadores em SystemVerilog Tabela 4.2 Precedncia de operadores em VHDL
249
A precedncia de operadores para SystemVerilog bem parecida com A multiplicao tem precedncia sobre adio em VHDL, como o leitor
o que o leitor esperaria em outras linguagens de programao. Em poderia esperar. No entanto, diferente de SystemVerilog, todas as
particular, AND tem precedncia sobre OR. Ns podemos tirar operaes lgicas (and, or, etc) possuem precedncias iguais, ao
vantagem dessa precedncia para eliminar os parnteses. contrrio do que voc poderia esperar em lgebra Booleana. Portanto,
os parnteses so necessrios; de outra forma, cout <= g or p
assign cout = g | p & cin; and cin poderia ser interpretado da esquerda para a direita, como
cout <= (g or p) and cin.
4.2.7. Nmeros
Os nmeros podem ser especificados em bases binria, octal, decimal ou hexadecimal (bases 2, 8, 10
e 16, respectivamente). O comprimento, isto , o nmero de bits, pode, opcionalmente, ser dado e ento
preenchido com zeros at atingir o comprimento. ndices abaixo dos nmeros so ignorados e podem ser
teis na quebra de grandes nmeros em pedaos menores e mais legveis. O Exemplo HDL 4.9 explica
como os nmeros so escritos em cada linguagem.
Exemplo HDL 4.9 NMEROS
SystemVerilog VHDL
O formato de declarao de constantes NBvalue, onde N o Em VHDL, nmeros STD_LOGIC so escritos em binrio entre aspas
tamanho, em bits, B uma letra especificando a base, e value o simples: 0 e 1 indicam nvel lgico 0 e 1. O formato para a
valor. Por exemplo, 9h25 um nmero de 9-bits com o valor de declarao de constantes STD_LOGIC_VECTOR NB value, onde N
2516 = 3710 = 0001001012 . A SystemVerilog aceita b para binrio, o comprimento em bits, B um indicador de base, e value indica o
o para octal, d para decimal e h para hexadecimal. Se a base valor. Por exemplo, 9X25 indica um nmero de 9-bits com o valor de
omitida, padronizada como sendo decimal. 2516 = 3710 = 0001001012 . VHDL 2008 aceita B para binrio, O
Se o tamanho no dado, considerado que o nmero tem tantos para octal, D para decimal, e X para hexadecimal.
bits quanto a expresso, no qual ele se encontra, est utilizando. Zeros Se a base omitida, , por padro, binria. Se o comprimento no
so automaticamente adicionados frente do nmero para deixa-lo dado, o nmero considerado como tendo o comprimento de
com o comprimento total. Por exemplo, se w um barramento de 6 acordo com o nmero de bits especificado em value. A partir de
bits, assign w = b11 d a w o valor de 000011. uma boa outubro de 2011, o software Synplify Premier, da Synopsys ainda no
prtica disponibilizar explicitamente o comprimento. Uma exceo aceitava a especificao de comprimento.
250
que 0 e 1 so comandos em SystemVerilog que preenche num others => 0 e others => 1 so comandos em VHDL
barramento todo com 0 e todo com 1, respectivamente. que preenchem todos os bits com 0 e 1, respectivamente.
Tabela 4.3 Nmeros em SystemVerilog Tabela 4.4 Nmeros em VHDL
251
4.2.8. Zs e Xs
As HDL usam z para indicar um valor flutuante, z particularmente til para descrever um buffer
tristate com a sada flutuante quando a entrada de ativao 0. Lembre-se, da Seo 2.6.2, em que um
barramento podia ser acionado por muitos buffers tristate, apenas um poderia estar ativado. Exemplo
HDL 4.10 mostra o comando para um buffer tristate. Se o buffer est ativado, a sada a mesma que a
entrada. Se o buffer est desativado, atribudo sada um valor flutuante (z).
Similarmente, as HDL usam x para indicar um nvel lgico invlido. Se um barramento levado
simultaneamente a 0 e 1 por dois buffers tristate ativados (ou outras portas), o resultado x, indicando
conteno. Se todos os buffers tristate que acionam o barramento esto simultaneamente desligados, o
valor no barramento ir flutuar, indicado por z.
No incio da simulao, ns com estados, tais como as sadas de flip-flops, so inicializadas com um
valor desconhecido (x em SystemVerilog e u em VHDL). Isso til para procurar erros causados pelo
esquecimento de reinicializao de flip-flops antes dos mesmos serem utilizados.
Exemplo HDL 4.10 BUFFER TRISTATE
SystemVerilog VHDL
module tristate(input logic [3:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic en,
output tri [3:0] y); entity tristate is
port(a: in STD_LOGIC_VECTOR(3 downto 0);
assign y = en ? a : 4'bz; en: in STD_LOGIC;
end;
Note que y declarado como tri ao invs de logic. Sinais do tipo
logic podem ter apenas um acionador. Barramentos tristate podem architecture synth of tristate is
ter mltiplos acionadores, ento, eles devem ser declarados como begin
uma net. Dois dos tipos de nets em SystemVerilog so denominadas y <= a when en else "ZZZZ";
end;
252
tri e trireg. Tipicamente, exatamente um acionador por net est

ativo por vez, e a net toma aquele valor. Se nenhum acionador est
ativo, tri flutua (z), enquanto trireg retm o valor anterior. Se
nenhum tipo for especificado para uma entrada ou sada, assumido
que seja tri. Note tambm que uma sada tri de um mdulo pode
ser utilizada como uma entrada logic para outro mdulo. A seo
4.7 discute melhor as nets e os acionadores mltiplos.
Figura 4.9 Circuito tristate sintetizado
Se uma porta recebe uma entrada flutuante, ela pode produzir uma sada x quando no puder
determinar o valor correto da sada. Similarmente, se ela receber uma entrada de valor ilegal ou no-
inicializado, pode produzir uma sada x. O Exemplo HDL 4.11 mostra como SystemVerilog e VHDL
combinam estes diferentes valores de sinal em portas lgicas.
Exemplo HDL 4.11 TABELAS VERDADE COM ENTRADAS INDEFINIDAS E FLUTUANTES
SystemVerilog VHDL
Valores de sinais em SystemVerilog so 0, 1, z e x. As restries em Sinais do tipo VHDL STD_LOGIC so 0, 1, z, x e u.

SystemVerilog iniciam-se com o fato de que z ou x so preenchidos A Tabela 4.6 mostra uma tabela verdade para uma porta AND
com zs ou xs (ao invs de 0) para atingir o comprimento total do utilizando todos os cinco possveis valores de sinal. Note que a porta
dado quando necessrio. pode, s vezes, determinar a sada mesmo com algumas entradas
A Tabela 4.5 mostra uma tabela verdade para uma porta AND sendo desconhecidas. Por exemplo, 0 and z retorna 0 pois a sada
utilizando todos os quatro possveis valores de sinal. Note que a porta de uma porta AND sempre 0 se alguma das entradas for 0. De
pode, algumas vezes, determinar a sada mesmo com algumas das outro modo, entradas invlidas ou flutuantes causam sadas invlidas,
253
entradas sendo desconhecidas. Por exemplo, 0 & z retorna 0. Pois a mostradas como x em VHDL. Entradas no-inicializadas causam
sada de uma porta AND sempre 0 se alguma das entradas 0. De sadas no-inicializadas, mostradas como u em VHDL.
outro modo, entradas flutuantes ou invlidas causam sadas invlidas,
mostradas como x em SystemVerilog.
Tabela 4.5 Tabela verdade de uma porta AND com z e x em Tabela 4.6 Tabela verdade de uma porta AND com z, x e u em VHDL
SystemVerilog
Ver valores x ou u na simulao , quase sempre, uma indicao de um bug ou de m prtica de

programao. Num circuito sintetizado, isso corresponde a uma entrada de porta flutuante, estado no
inicializado ou conteno. O x ou u pode ser interpretado aleatoriamente pelo circuito como sendo 0 ou
1, levando-o a um comportamento imprevisvel.
254
4.2.9. Reorganizao de Bits

Muitas vezes necessrio operar num subconjunto de um barramento ou ento concatenar (juntar)
sinais a fim de formar barramentos. Estas operaes so coletivamente denominadas reorganizao de
bits (bit swizzling). No Exemplo HDL 4.12, y dado como um valor de 9-bits, 2 1 0 0 0 0 101 utilizando
operaes de reorganizao de bits.
Exemplo HDL 4.12 REORGANIZAO DE BITS
SystemVerilog VHDL
assign y = {c[2:1], {3{d[0]}}, c[0], 3'b101}; y <=(c(2 downto 1), d(0), d(0), d(0), c(0),
3B"101");
O operador { } utilizado para concatenar barramentos. {3{d[0]}}
indica trs cpias de d[0]. O operador de agregao ( ) usado para concatenar barramentos. y
No confunda a constante binria de 3-bits 3'b101 com um deve ser do tipo STD_LOGIC_VECTOR de 9 bits.
barramento denominado b. Note que foi fundamental especificar o Outro exemplo demonstra o poder das agregaes VHDL. Assumindo
comprimento de 3-bits na constante; de outra forma, poderia haver que z um STD_LOGIC_VECTOR de 8 bits, a z dado o valor 10010110
um nmero desconhecido de zeros que poderia aparecer no meio de utilizando-se o seguinte comando de agregao:
y.
Se y fosse menor do que 9-bits, zeros poderiam ser colocados nos z <= ("10", 4 => '1', 2 downto 1 =>'1', others
bits mais significativos. =>'0')
O 10 o primeiro par de bits. So ento colocados 1s no bit 4 e nos

bits 2 e 1. Os outros bits so 0.
255
4.2.10. Atrasos
As declaraes HDL podem ser associadas a atrasos especificados em unidades arbitrrias. Eles so
teis durante a simulao para prever o quo rpido um circuito vai funcionar (se o leitor especificar os
atrasos mais significativos), e tambm para propsitos de debugging, para entender a causa e o efeito
(seguir a fonte de uma sada ruim complicado se todos os sinais mudam simultaneamente nos
resultados de uma simulao). Esses atrasos so ignorados durante a sntese; o atraso de uma porta
produzido pelo sintetizador depende das especificaes e , e no de nmeros no cdigo HDL.
O Exemplo HDL 4.13 adiciona atrasos funo original do Exemplo HDL 4.1, = + + .
Ele assume que os inversores tm um atraso de 1 ns, as portas AND de trs entradas tm atrasos de 2 ns,
e as portas OR de trs entradas possuem atrasos de 4 ns. A Figura 4.10 mostra as formas de onda das
simulaes, com y atrasado 7 ns depois das entradas. Note que y inicialmente desconhecido no
comeo da simulao.
Exemplo HDL 4.13 PORTAS LGICAS COM ATRASOS
SystemVerilog VHDL
timescale 1ns/1ps library IEEE; use IEEE.STD_LOGIC_1164.all;

module example(input logic a, b, c,
output logic y); entity example is
port(a, b, c: in STD_LOGIC;
logic ab, bb, cb, n1, n2, n3; y: out STD_LOGIC);
end;
assign #1 {ab, bb, cb} = ~{a, b, c};
assign #2 n1 = ab & bb & cb; architecture synth of example is
assign #2 n2 = a & bb & cb; signal ab, bb, cb, n1, n2, n3: STD_LOGIC;
assign #2 n3 = a & bb & c; begin
assign #4 y = n1 | n2 | n3; ab <= not a after 1 ns;
endmodule bb <= not b after 1 ns;
cb <= not c after 1 ns;
Os arquivos em SystemVerilog podem incluir uma diretiva de escala n1 <= ab and bb and cb after 2 ns;
de tempo que indica o valor de cada unidade de tempo. A declarao n2 <= a and bb and cb after 2 ns;
n3 <= a and bb and c after 2 ns;
256
da forma timescale unidade/preciso. Neste arquivo, y <= n1 or n2 or n3 after 4 ns;

cada unidade possui 1 ns, e a simulao possui 1 ps de preciso. Se end;
nenhuma diretiva de escala de tempo dada no arquivo, a unidade
padro de preciso (normalmente, 1 ns para ambas) utilizada. Em Em VHDL, a clusula after utilizada para indicar atraso. As
SystemVerilog, o smbolo # utilizado para indicar o nmero de unidades, neste caso, so especificadas em nanossegundos.
unidades do atraso. Ele pode ser colocado na declarao assign,
assim como atribuies de bloco (=) e no-blocos (<=), como ser
discutido na Seo 4.5.4.
Figura 4.10 Exemplo de formas de onda com atrasos (do simulador ModelSim)
4.3. MODELAGEM ESTRUTURAL

Foi discutida, na seo anterior, a modelagem comportamental, descrevendo um mdulo em termos
das relaes entre as entradas e as sadas. Esta seo examina a modelagem estrutural, descrevendo um
mdulo em termos de como ele composto por mdulos mais simples.
Por exemplo, o Exemplo HDL 4.14 mostra como montar um multiplexador 4:1 a partir de trs
multiplexadores 2:1. Cada cpia do multiplexador 2:1 chamada de instncia. Mltiplas instncias de um
257
mesmo mdulo so distinguidas por nomes distintos, nesse caso, lowux, highmux e finalmux. Isso
um exemplo de regularidade, no qual um multiplexador 2:1 reutilizado muitas vezes.
Exemplo HDL 4.14 MODELO ESTRUTURAL DE UM MULTIPLEXADOR 4:1
SystemVerilog VHDL
module mux4(input logic [3:0] d0, d1, d2, d3, library IEEE; use IEEE.STD_LOGIC_1164.all;
output logic [3:0] y); entity mux4 is
port(d0, d1,
logic [3:0] low, high; d2, d3: in STD_LOGIC_VECTOR(3 downto 0);
s: in STD_LOGIC_VECTOR(1 downto 0);
mux2 lowmux(d0, d1, s[0], low); y: out STD_LOGIC_VECTOR(3 downto 0));
mux2 highmux(d2, d3, s[0], high); end;
mux2 finalmux(low, high, s[1], y);
endmodule architecture struct of mux4 is
component mux2
As trs instncias mux2 so denominadas lowmux, highmux e port(d0,
finalmux. O mdulo mux2 deve ser definido num outro lugar no d1: in STD_LOGIC_VECTOR(3 downto 0);
cdigo SystemVerilog vide Exemplo HDL 4.5, Exemplo HDL 4.15 ou s: in STD_LOGIC;
Exemplo HDL 4.34. y: out STD_LOGIC_VECTOR(3 downto 0));
end component;
signal low, high: STD_LOGIC_VECTOR(3 downto
0);
begin
lowmux: mux2 port map(d0, d1, s(0), low);
highmux: mux2 port map(d2, d3, s(0), high);
finalmux: mux2 port map(low, high, s(1), y);
end;
A arquitetura deve primeiro declarar os portos mux2 utilizando a

declarao component. Isso permite s ferramentas VHDL verificar
258
que os componentes que o leitor deseja utilizar possuem as mesmas

portas que a entidade que foi declarada noutra declarao,
prevenindo erros causados pela mudana de entidade, mas no da
instncia. No entanto, a declarao de componentes torna o cdigo
VHDL bastante trabalhoso.
O Exemplo HDL 4.15 utiliza modelagem estrutural para construir um multiplexador 2:1 a partir de um
par de buffers tristate. Construir lgica a partir de tristates, no entanto, no recomendado.
Exemplo HDL 4.15 MODELO ESTRUTURAL DE UM MULTIPLEXADOR 2:1
SystemVerilog VHDL
module mux2(input logic [3:0] d0, d1, library IEEE; use IEEE.STD_LOGIC_1164.all;
input logic s,
output tri [3:0] y); entity mux2 is
259
tristate t0(d0, ~s, y); s: in STD_LOGIC;

tristate t1(d1, s, y); y: out STD_LOGIC_VECTOR(3 downto 0));
endmodule end;
Em SystemVerilog, expresses como ~s so permitidas na lista de architecture struct of mux2 is

portos para uma instncia. Expresses arbitrariamente complicadas component tristate
so permitidas, mas desencorajadas, pois elas deixam o cdigo difcil port(a: in STD_LOGIC_VECTOR(3 downto 0);
de ler. en: in STD_LOGIC;
end component;
signal sbar: STD_LOGIC;
begin
sbar <= not s;
t0: tristate port map(d0, sbar, y);
t1: tristate port map(d1, s, y);
end;
Em VHDL, expresses como not s no so permitidas no mapa de

portos para uma instncia. Portanto, sbar deve ser definido como um
sinal separado.
260
O Exemplo HDL 4.16 mostra como mdulos podem acessar parte de um barramento. Um
multiplexador de 8-bits construdo utilizando-se dois multiplexadores 2:1 de 4-bits j definidos,
operando cada um deles os 4-bits mais e menos significativos, respectivamente.
Em geral, os sistemas complexos so projetados hierarquicamente. O sistema como um todo
descrito estruturalmente instanciando-se os seus componentes principais. Cada um destes
componentes descrito estruturalmente a partir dos seus blocos lgicos, e assim por diante,
recursivamente, at que as partes sejam simples o suficiente para serem descritas de modo
comportamental. Este um bom estilo para se evitar (ou ao menos, minimizar) a confuso entre
descries estruturais e comportamentais dentro de um mesmo mdulo.
Exemplo HDL 4.16 ACESSANDO PARTES DE BARRAMENTOS
SystemVerilog VHDL
module mux2_8(input logic [7:0] d0, d1, library IEEE; use IEEE.STD_LOGIC_1164.all;
input logic s,
output logic [7:0] y); entity mux2_8 is
mux2 lsbmux(d0[3:0], d1[3:0], s, y[3:0]); s: in STD_LOGIC;
mux2 msbmux(d0[7:4], d1[7:4], s, y[7:4]); y: out STD_LOGIC_VECTOR(7 downto 0));
endmodule end;
architecture struct of mux2_8 is
component mux2
s: in STD_LOGIC;
end component;
begin
lsbmux: mux2
port map(d0(3 downto 0), d1(3 downto 0),
s, y(3 downto 0));
msbmux: mux2
port map(d0(7 downto 4), d1(7 downto 4),
261
s, y(7 downto 4));

end;
Figura 4.13 Circuito mux2_8 sintetizado
4.4. LGICA SEQUENCIAL

Os sintetizadores de HDL reconhecem certas linguagens e as transformam em circuitos sequenciais.
Outros estilos de cdigo podem simular corretamente os circuitos, porm com erros flagrantes ou sutis.
Esta seo apresenta as linguagens apropriadas para descrever registradores e bsculas.
4.4.1. Registradores
A grande maioria dos sistemas comerciais modernos so construdos com registradores utilizando flip-
flops D com disparo na borda positiva. O Exemplo HDL 4.17 mostra como escrever tais flip-flops.
262
Nas declaraes always em SystemVerilog, e process, em VHDL, os sinais mantm o seu valor
antigo at que um evento na lista de sensibilidade acontea e, explicitamente, causem a sua mudana.
Consequentemente, tais cdigos, com apropriadas listas de sensibilidade, podem ser utilizados para
descrever circuitos sequenciais com memria. Por exemplo, o flip-flop possui apenas clk na sua lista de
sensibilidade. Ele guarda o ltimo valor de q at prxima borda de subida de clk, mesmo se d muda
temporariamente.
Em contraste, declaraes de atribuio contnua (assign) em SystemVerilog, e declaraes de

atribuio simultnea (<=) em VHDL so reavaliadas a todo momento em que qualquer uma das
entradas do lado direito muda. Portanto, seu cdigo necessariamente descreve lgica combinatria.
Exemplo HDL 4.17 REGISTRADOR
SystemVerilog VHDL
module flop(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic [3:0] d,
output logic [3:0] q); entity flop is
port(clk: in STD_LOGIC;
always_ff @(posedge clk) d: in STD_LOGIC_VECTOR(3 downto 0);
q <= d; q: out STD_LOGIC_VECTOR(3 downto 0));
endmodule end;
Em geral , uma declarao always em SystemVerilog escrita da architecture synth of flop is

seguinte foma: begin
process(clk) begin
always @(lista de sensibilidade) if rising_edge(clk) then
declarao; q <= d;
end if;
A declarao executada apenas quando algum evento especificado end process;
na lista de sensibilidade ocorre. Nesse exemplo, a declaracao q <= end;
d. Consequentemente, o flip-flop copia d para q na borda de subida
Uma declarao process, em VHDL, escrita na forma:
263
do clock e, em outro caso, guarda o valor antigo de q. Note que a lista

de sensibilidade tambm referida como lista de estmulos. process(lista de sensibilidade) begin
<= chamado de declarao nonblocking. Pense nela como sendo um declarao;
sinal = comum por enquanto; ns retornaremos aos pontos mais sutis end process
na Seo 4.5.4. Note que <= usada ao invs de uma declarao
assign dentro de uma always. A declarao statement executada quando qualquer uma das
variveis na lista de sensibilidade muda. Neste exemplo, a declarao
Assim como veremos nas sees subsequentes, declaraes always
podem ser usadas para indicar flip-flops, bsculas ou lgica if verifica se a mudana ocorre no flanco ascendente do clk. Se sim,
combinatria, dependendo da lista de sensibilidade e das declaraes. ento q <= d. Consequentemente, o flip-flop copia d para q na borda
Devido a essa sensibilidade, fcil produzir, inadvertidamente, positiva do clock e, noutro caso, guarda o estado anterior de q.
hardware errado. SystemVerilog introduz as declaraes Uma alternativa em VHDL para declarar flip-flops :
always_ff, always_bscula e always_comb a fim de reduzir
process(clk) begin
o risco de erros comuns. always_ff se comporta como uma
if clk'event and clk = '1' then
always, mas utilizada exclusivamente para indicar flip-flops, e q <= d;
permite s ferramentas produzirem mensagens de advertncia se end if;
alguma outra coisa for indicada. end process;
rising_edge(clk) sinnimo de clkevent and clk =

1
Figura 4.14 Circuito flop sintetizado
4.4.2. Registradores Resettable

Quando a simulao iniciada, ou quando o circuito alimentado, a sada de um flop ou registrador
desconhecida. Isso indicado por um x em SystemVerilog e por u em VHDL. Geralmente, uma boa
264
prtica utilizar registradores resettable de modo que, quando alimentado, o leitor possa colocar o seu
sistema num estado conhecido. O reset pode ser tanto assncrono como sncrono. Lembre-se que o reset
assncrono ocorre imediatamente, enquanto o reset sncrono zera a sada apenas na borda de subida
seguinte do clock. O Exemplo HDL 4.18 demonstra o cdigo para flip-flops com resets assncronos e
sncronos. Observe que distinguir um reset sncrono ou assncrono num esquemtico pode ser difcil. O
esquemtico produzido pelo Synplify Premier coloca o reset assncrono abaixo do flip-flop, e o reset
sncrono no lado esquerdo.
Exemplo HDL 4.18 REGISTRADOR RESETTABLE
SystemVerilog VHDL
module flopr(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic reset,
input logic [3:0] d, entity flopr is
output logic [3:0] q); port(clk, reset: in STD_LOGIC;
d: in STD_LOGIC_VECTOR(3 downto 0);
// asynchronous reset q: out STD_LOGIC_VECTOR(3 downto 0));
always_ff @(posedge clk, posedge reset) end;
if (reset) q <= 4'b0;
else q <= d; architecture asynchronous of flopr is
endmodule begin
process(clk, reset) begin
module flopr(input logic clk, if reset then
input logic reset, q <= "0000";
input logic [3:0] d, elsif rising_edge(clk) then
output logic [3:0] q); q <= d;
end if;
// synchronous reset end process;
always_ff @(posedge clk) end;
else q <= d; library IEEE; use IEEE.STD_LOGIC_1164.all;
endmodule
265
Sinais mltiplos numa lista de sensibilidade de declarao always entity flopr is

so separados por uma vrgula ou pela palavra or. Note que port(clk, reset: in STD_LOGIC;
posedge reset est na lista de sensibilidade do flop resettable d: in STD_LOGIC_VECTOR(3 downto 0);
assincronamente, mas no na lista do flop resettable de modo q: out STD_LOGIC_VECTOR(3 downto 0));
end;
sncrono. Portanto, o flop resettable de modo assncrono responde,
imediatamente, ao flanco de subida em reset, mas o flop resettable de architecture synchronous of flopr is
modo sncrono responde a reset apenas no flanco de subida do clock. begin
Devido aos mdulos terem o mesmo nome, flopr, o leitor pode process(clk) begin
incluir apenas um ou outro no seu projeto. if rising_edge(clk) then
if reset then q <= "0000";
else q <= d;
end if;
end if;
end process;
end;
Mltiplos sinais numa lista de sensibilidade process so separados

por vrgula. Note que o reset est dentro da lista de sensisbilidade
no flop resettable assincronamente, mas no na do flop resettable
sincronamente. Portanto, o flop resettable assincronamente responde
imediatamente no flanco ascendente do reset, mas o flop resettable
sincronamente responde ao reset apenas no flanco de subida do
clock.
Lembre-se que o estado do flop inicializado com u durante a
simulao VHDL.
Como mencionado anteriormente, o nome da arquitetura (assncrona
ou sncrona, nesse exemplo) ignorado pelas ferramentas VHDL, mas
podem ser teis para o humano lendo o cdigo. Devido a ambas as
arquiteturas descreverem a entidade flopr, o leitor pode incluir
apenas uma ou outra no seu projeto.
266
Figura 4.15 Circuito flopr sintetizado: (a) reset assncrono, (b) reset sncrono
4.4.3. Registradores Enabled

Registradores enabled respondem ao clock apenas quando a liberao (enable) confirmada. O
Exemplo HDL 4.19 mostra um registrador ativado enabled assincronamente que retm seu valor antigo
se tanto reset quanto en so FALSE.
Exemplo HDL 4.19 REGISTRADOR REINICIVEL ENABLED
SystemVerilog VHDL
module flopenr(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic reset,
input logic en, entity flopenr is
input logic [3:0] d, port(clk,
output logic [3:0] q); reset,
en: in STD_LOGIC;
d: in STD_LOGIC_VECTOR(3 downto 0);
267
// asynchronous reset q: out STD_LOGIC_VECTOR(3 downto 0));

always_ff @(posedge clk, posedge reset) end;
else if (en) q <= d; architecture asynchronous of flopenr is
endmodule asynchronous reset
begin
if reset then
q <= "0000";
elsif rising_edge(clk) then
if en then
q <= d;
end if;
end if;
end process;
end;
Figura 4.16 Circuito flopenr sintetizado
268
4.4.4. Registradores Mltiplos

Uma nica declarao always/process pode ser utilizada para descrever mltiplas partes de
hardware. Por exemplo, considere o sincronizador da Seo 3.5.5, feito a partir de dois flip-flops back-to-
back, como mostrado na Figura 4.17. O Exemplo HDL 4.20 descreve o sincronizador. No flanco ascendente
clk, d copiado para n1. Ao mesmo tempo, n1 copiado para q.
Figura 4.17 Circuito sincronizador
Exemplo HDL 4.20 SINCRONIZADOR
SystemVerilog VHDL
module sync(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic d,
output logic q); entity sync is
logic n1; port(clk: in STD_LOGIC;
d: in STD_LOGIC;
always_ff @(posedge clk) q: out STD_LOGIC);
begin end;
n1 <= d; // nonblocking
q <= n1; // nonblocking architecture good of sync is
end signal n1: STD_LOGIC;
endmodule begin
process(clk) begin
Note que o construtor begin/end necessrio pois declaraes if rising_edge(clk) then
mltiplas aparecem na declarao always. Isso anlogo s chaves n1 <= d;
q <= n1;
269
{ } em C ou Java. O begin/end no seria necessrio no exemplo end if;

flopr pois if/else contam como apenas uma declarao. end process;
end;
n1 deve ser declarado como signal pois ele um sinal interno

utilizado no mdulo.
Figura 4.18 Circuito sync sintetizado
4.4.5. Bsculas
Lembre-se, da Seo 3.2.2, que uma bscula D est transparente quando o clock est a HIGH,
permitindo ao dado fluir da entrada para a sada. A bscula se torna opaca quando o clock est a LOW,
retendo o seu estado antigo. O Exemplo HDL 4.21 mostra o cdigo para uma bscula D.
Nem todas as ferramentas de sntese aceitam as bsculas convenientemente. A no ser que o leitor
saiba que a sua ferramenta aceita bsculas, e que tenha uma boa razo para us-las, evite-as, e, ao invs
deles, utilize flip-flops com disparo pelo flanco. Alm disso, tome cuidado para que a sua HDL no recorra
a uma bscula intencional, algo que fcil de ocorrer se caso o leitor no estiver atento. Muitas
ferramentas de sntese o advertem quando uma bscula criada; se voc no esperava uma, localize o
bug na sua HDL. E se o leitor no sabe se quer uma bscula ou no, provavelmente est aproximando a
HDL de uma linguagem de programao, e, nesse caso, existem grandes problemas espreita.
270
4.5. MAIS LGICA COMBINATRIA

Na Seo 4.2, utilizamos declaraes de atribuio para descrever lgica combinatria de modo
comportamental. As declaraes always, em SystemVerilog, e process, em VHDL, so utilizadas para
descrever circuitos sequenciais, pois retm o estado antigo quando nenhum estado novo estabelecido.
No entanto, as declaraes always/process tambm podem ser usadas para descrever lgica
combinatria de modo comportamental, se a lista de sensibilidade for escrita para responder a mudanas
em todas as entradas, e o corpo estabelecer o valor da sada para cada possvel combinao na entrada.
O Exemplo HDL 4.22 utiliza declaraes always/process para descrever um banco de quatro
inversores (veja a Figura 4.3 para o circuito sintetizado).
Exemplo HDL 4.21 BSCULA D
SystemVerilog VHDL
module bscula(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [3:0] q); entity bscula is
always_bscula port(clk: in STD_LOGIC;
if (clk) q <= d; d: in STD_LOGIC_VECTOR(3 downto 0);
endmodule q: out STD_LOGIC_VECTOR(3 downto 0));
end;
always_latch equivalente a always@(clk,d), e o modo
preferido para se descrever uma bscula em SystemVerilog. Ele architecture synth of bscula is
avaliado todas as vezes em que clk ou d muda de valor. Se clk begin
est HIGH, d flui atravs de q. Ento, este cdigo descreve uma process(clk, d) begin
if clk = '1' then
bscula sensvel a um nvel positivo. De outro modo, q mantm o seu
q <= d;
valor anterior. A SystemVerilog pode gerar uma advertncia se o bloco end if;
always_latch no indicar uma bscula. end process;
end;
271
A lista de sensibilidade contm ambos, clk e d, ento, process

avaliado a qualquer momento em que clk ou d mudam de valor. Se
clk est HIGH, d flui para q.
Figura 4.19 Circuito bscula sintetizado
Exemplo HDL 4.22 INVERSOR UTILIZANDO ALWAYS/PROCESS
SystemVerilog VHDL
module inv(input logic [3:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [3:0] y);
always_comb entity inv is
y = ~a; port(a: in STD_LOGIC_VECTOR(3 downto 0);
end;
always_comb reavalia as declaraes dentro da declarao
always a qualquer momento que os sinais do lado direito de <=, ou architecture proc of inv is
de =, mudem. Nesse caso, ele equivalente a always @(a), mas begin
melhor, pois evita erros se os sinais da declarao always forem process(all) begin
y <= not a;
renomeados ou adicionados. Se o cdigo dentro do bloco always
end process;
no de lgica combinatria, a SystemVerilog gera uma advertncia. end;
272
always_comb equivalente a always @(*), mas prefervel em process(all) reavalia as declaraes dentro de process a
SystemVerilog. qualquer momento em que algum dos sinais em process mude de
O sinal = dentro da declarao always chamado atribuio valor. equivalente a process(a), mas melhor, pois evita erros
blocking, em contraste com a atribuio <=. Em SystemVerilog uma se os sinais em process forem renomeados ou adicionados.
boa prtica utilizar atribuies blocking para logica combinatrio e As declaraes begin e end so exigidas em VHDL, apesar de
atribuies nonblocking para lgica sequencial. Isso ser discutido de process conter apenas uma declarao.
forma detalhada na Seo 4.5.4.
As HDL aceitam declaraes blocking e nonblocking numa declarao always/process. Um grupo
de declaraes blocking avaliado na ordem em que aparecem no cdigo, do mesmo modo em que numa
linguagem de programao padro. Um grupo de declaraes nonblocking avaliado simultaneamente;
todas as declaraes so avaliadas antes de qualquer sinal do lado esquerdo seja atualizado.
O Exemplo HDL 4.23 define um full adder utilizando os sinais intermedirios p e g para computar s e
cout. Ele produz o mesmo circuito da Figura 4.8, mas utiliza declaraes always/process no lugar
de declaraes de atribuio.
Estes dois exemplos so aplicaes ruins das declaraes always/process para a modelagem de
logica combinatria, pois eles requerem mais linhas do que suas aproximaes equivalentes com
declaraes de atribuio, dos Exemplo HDL 4.2 e Exemplo HDL 4.7. No entanto, as declaraes case e
if so convenientes para modelar lgica combinatria mais complexa. Declaraes case e if devem
aparecer dentro de uma declarao always/process, e sero examinadas nas prximas sees.
SystemVerilog VHDL
Numa declarao always em SystemVerilog = indica uma Numa declarao process, em VHDL, := indica uma declarao
atribuio blocking e <= indica uma declarao nonblocking (tambm blocking, e <= indica uma declarao nonblocking (tambm chamada
chamada de declarao concorrente). declarao simultnea). Esta a primeira seo onde :=
No confunda nenhum tipo com atribuio contnua utilizando a introduzido.
declarao assign. A declarao assign deve ser utilizada fora Declaraes nonblocking so feitas para sadas e para sinais.
das declaraes always e tambm so avaliadas simultaneamente. Declaraes blocking so feitas para variveis, as quais so declaradas
na declarao process (veja Exemplo HDL 4.23). <= tambm pode
273
aparecer fora de declaraes process, onde tambm avaliado

simultaneamente.
Exemplo HDL 4.23 FULL ADDER UTILIZANDO ALWAYS/PROCESS
SystemVerilog VHDL
module fulladder(input logic a, b, cin, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic s, cout);
always_comb s, cout: out STD_LOGIC);
begin end;
p = a ^ b; // blocking
g = a & b; // blocking architecture synth of fulladder is
begin
s = p ^ cin; // blocking process(all)
cout = g | (p & cin); // blocking variable p, g: STD_LOGIC;
end begin
endmodule p := a xor b; blocking
g := a and b; blocking
Nesse caso, always @(a, b, cin) poderia ser equivalente a s <= p xor cin;
always_comb. No entanto, always_comb melhor pois evita cout <= g or (p and cin);
erros comuns, como o esquecimento de sinais na lista de end process;
sensibilidade. end;
Por razes que sero discutidas na Seo 4.5.4 melhor utilizar
declaraes blocking para lgica combinatria. Esse exemplo utiliza Nesse caso, process(a, b, cin) poderia ser equivalente a
declaraes blocking, primeiro computando p, depois g, depois s, e process(all). No entanto, process(all) melhor pois evita
finalmente, cout. erros comuns, como o esquecimento de sinais na lista de
sensibilidade.
274
Por razes que sero discutidas na Seo 4.5.4, melhor utilizar

declaraes blocking para a lgica combinatria. Este exemplo utiliza
declaraes blocking para p e g para que eles adquiram novos valores
antes de serem utilizados para computar s e cout, que dependem
deles.
Devido a p e g aparecerem do lado esquerdo da declarao blocking
(:=) em process, eles devem ser declarados como sendo
variable, ao invs de signal. A declarao de variveis aparece
antes de begin no processo onde a varivel usada.
4.5.1. Declaraes Case

Uma boa aplicao do uso das declaraes always/process para lgica combinatria o
decodificador de display de sete segmentos, que tira vantagem da declarao case, que, por sua vez,
deve aparecer dentro da declarao always/process.
Como o leitor deve ter notado no decodificador de display de sete segmentos do exemplo 2.10, o
processo de projeto para grandes blocos de lgica combinatria tedioso e passvel de erros. As HDL
oferecem uma grande melhora, permitindo ao leitor especificar a funo num nvel de abstrao maior,
e ento, automaticamente, sintetizar a funo em portas. O Exemplo HDL 4.24 usa declaraes case
para descrever um decodificador de display de sete segmentos baseado em sua tabela verdade. A
declarao case realiza diferentes aes, dependendo do valor de sua entrada. Uma declarao case
indica lgica combinatria se todas as possveis combinaes de entrada so definidas; de outro modo,
ela indica lgica sequencial, pois, nos casos indefinidos, a sada ir manter o seu antigo valor.
Exemplo HDL 4.24 DECODIFICADOR DE DISPLAY DE SETE SEGMENTOS
SystemVerilog VHDL
module sevenseg(input logic [3:0] data, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [6:0] segments);
entity seven_seg_decoder is
port(data: in STD_LOGIC_VECTOR(3 downto 0);
275
always_comb segments: out STD_LOGIC_VECTOR(6 downto

case(data) 0));
// abc_defg end;
0: segments = 7'b111_1110;
1: segments = 7'b011_0000; architecture synth of seven_seg_decoder is
2: segments = 7'b110_1101; begin
3: segments = 7'b111_1001; process(all) begin
4: segments = 7'b011_0011; case data is
5: segments = 7'b101_1011; abcdefg
6: segments = 7'b101_1111; when X"0" => segments <= "1111110";
default: segments = 7'b000_0000; when X"4" => segments <= "0110011";
endcase when X"5" => segments <= "1011011";
endmodule when X"6" => segments <= "1011111";
when X"7" => segments <= "1110000";
A declarao case verifica o valor de data. Quando data 0, a when X"8" => segments <= "1111111";
declarao realiza a ao depois da vrgula, activando segments when X"9" => segments <= "1110011";
para 1111110. A declarao case similarmente verifica outros when others => segments <= "0000000";
valores de dados maiores do que 9 (sem uso para a base padro, 10). end case;
end process;
A clusula default um modo conveniente de definir as sadas para
end;
todos os casos no listados explicitamente, garantindo combinao
lgica. A declarao case verifica o valor de data. Quando data 0, a
Em SystemVerilog, declaraes case devem aparecer dentro de
declarao realiza a ao aps >=, activando segments para
declaraes always.
1111110. A declarao case similarmente verifica outros valores de
dados maiores do que 9 (note o uso de X para nmeros hexadecimais).
A clusula others um modo conveniente de definir a sada para
todos os casos no listados explicitamente, garantindo a lgica
combinatria.
Diferente de SystemVerilog, VHDL suporta declaraes de atribuies
de sinais selecionados (veja o exemplo 4.6), as quais se parecem muito
com declaraes case, mas podem aparecer fora dos processos.
276
Portanto, existem menos razes para se utilizar processos para

descrever lgica combinatria.
Figura 4.20 Circuito sevenseg sintetizado
O software Synplify Premier sintetiza o decodificador de display de sete segmentos numa read-only
memory (ROM) contendo 7 sadas para cada uma das 16 entradas possveis. As ROM so discutidas melhor
na Seo 5.5.6.
Se as clusulas default ou others estiverem fora da declarao case, o decodificador deveria

lembrar o seu valor anterior de sada a qualquer momento em que o dado estiver na faixa de 10-15. Isso
um comportamento estranho para um hardware.
Os decodificadores ordinrios tambm so comumente escritos com declaraes case. O Exemplo

HDL 4.25 descreve um decodificador 3:8.
Exemplo HDL 4.25 DECODIFICADOR 3:8
SystemVerilog VHDL
module decoder3_8(input logic [2:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

always_comb entity decoder3_8 is
case(a) port(a: in STD_LOGIC_VECTOR(2 downto 0);
3'b000: y = 8'b00000001; y: out STD_LOGIC_VECTOR(7 downto 0));
3'b001: y = 8'b00000010; end;
3'b010: y = 8'b00000100;
277
3'b011: y = 8'b00001000; architecture synth of decoder3_8 is

3'b100: y = 8'b00010000; begin
3'b101: y = 8'b00100000; process(all) begin
3'b110: y = 8'b01000000; case a is
3'b111: y = 8'b10000000; when "000" => y <= "00000001";
default: y = 8'bxxxxxxxx; when "001" => y <= "00000010";
endcase when "010" => y <= "00000100";
endmodule when "011" => y <= "00001000";
when "100" => y <= "00010000";
A declarao default no estritamente necessria, neste caso, when "101" => y <= "00100000";
para a sntese lgica, pois todas as possveis combinaes da entrada when "110" => y <= "01000000";
so definidas, mas prudente para a simulao, no caso de uma das when "111" => y <= "10000000";
entradas ser x ou z. when others => y <= "XXXXXXXX";
end case;
end process;
end;
A declarao others no estritamente necessria, neste caso, para

a sntese lgica, pois todas as possveis combinaes da entrada so
definidas, mas prudente para a simulao, no caso de uma das
entradas ser x , z ou u.
278
Figura 4.21 Circuito decoder3_8 sintetizado
279
4.5.2. Declaraes If
Declaraes always/process podem conter declaraes if. A declarao if pode ser seguida
por uma declarao else. Se todas as possveis combinaes de entrada esto cobertas, a declarao
indica lgica combinatria; de outro modo, ela produz lgica sequencial (da mesma forma que a bscula
na Seo 4.4.5).
O Exemplo HDL 4.26 utiliza declaraes if para descrever um circuito de prioridade, definido na Seo
2.4. Lembre-se que um circuito prioridade de N-entradas ativa a sada que corresponde entrada mais
significativa que est no nvel TRUE.
Exemplo HDL 4.26 CIRCUITO PRIORIDADE
SystemVerilog VHDL
module priorityckt(input logic [3:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

entity priorityckt is
always_comb port(a: in STD_LOGIC_VECTOR(3 downto 0);
if (a[3]) y <= 4'b1000; y: out STD_LOGIC_VECTOR(3 downto 0));
else if (a[2]) y <= 4'b0100; end;
else if (a[1]) y <= 4'b0010;
else if (a[0]) y <= 4'b0001; architecture synth of priorityckt is
else y <= 4'b0000; begin
endmodule process(all) begin
if a(3) then y <= "1000";
Em SystemVerilog, declaraes if devem aparecer dentro de elsif a(2) then y <= "0100";
declaraes always elsif a(1) then y <= "0010";
elsif a(0) then y <= "0001";
else y <= "0000";
end if;
end process;
end;
280
Ao contrrio de SystemVerilog, VHDL aceita declaraes de atribuio

de sinais condicionais (vide exemplo HDL 4.6), onde h muito mais
declaraes if, mas podem aparecer fora dos processos. Portanto,
existem menos razes para se usar processos para descrever lgica
combinatria.
Figura 4.22 Circuito priorityckt sintetizado
4.5.3. Tabelas Verdade com Dont Cares

Como examinado na Seo 2.7.3, as tabelas verdade podem incluir dont cares, permitindo assim uma
maior simplificao da lgica. O Exemplo HDL 4.27 mostra como descrever um circuito prioridade com
dont cares.
281
O sintetizador Synplify Premier gera um circuito um pouco diferente para esse mdulo (mostrado na
Figura 4.23), do que o circuito prioridade da Figura 4.22. No entanto, os circuitos so logicamente
equivalentes.
Exemplo HDL 4.27 CIRCUITO PRIORIDADE UTILIZANDO DONT CARES
SystemVerilog VHDL
module priority_casez(input logic [3:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

entity priority_casez is
always_comb port(a: in STD_LOGIC_VECTOR(3 downto 0);
casez(a) y: out STD_LOGIC_VECTOR(3 downto 0));
4'b1???: y <= 4'b1000; end;
4'b01??: y <= 4'b0100;
4'b001?: y <= 4'b0010; architecture dontcare of priority_casez is
4'b0001: y <= 4'b0001; begin
default: y <= 4'b0000; process(all) begin
endcase case? a is
endmodule when "1---" => y <= "1000";
when "01--" => y <= "0100";
A declarao casez age como uma declarao case, exceto pelo when "001-" => y <= "0010";
fato de que tambm reconhece ? como dont care when "0001"=> y <= "0001";
when others=> y <= "0000";
end case?;
end process;
end;
A declarao case? age como uma declarao case, exceto pelo

fato de que tambm reconhece como dont care.
282
Figura 4.23 Circuito priority_casez sintetizado
4.5.4. Atribuies Blocking e Nonblocking

As orientaes abaixo explicam quando e como utilizar cada tipo de atribuio. Se essas orientaes
no forem seguidas, possvel que o leitor escreva um cdigo que aparentemente funciona na simulao,
mas sintetiza o hardware incorretamente. O restante opcional desta seo explica os princpios por trs
dessas orientaes.
283
ORIENTAES PARA ATRIBUIES BLOCKING E NONBLOCKING
SystemVerilog VHDL
1. Use always_ff @(posedge clk) e atribuies 1. Utilize process(clk) e atribuies nonblocking para a
nonblocking para a modelagem de lgicas sequenciais modelagem de lgicas sequenciais sncronas.
sncronas.
process(clk) begin
always_ff @(posedge clk) if rising_edge(clk) then
begin n1 <= d; nonblocking
n1 <= d; // nonblocking q <= n1; nonblocking
q <= n1; // nonblocking end if;
end end process;
2. Utilize atribuies contnuas para a modelagem de lgicas 2. Utilize atribuies concorrentes do lado de fora das
combinatrias simples. declaraes process para a modelagem de lgicas
combinatrias simples.
assign y = s ? d1 : d0;
y <= d0 when s = '0' else d1;
3. Utilize always_comb e atribuies blocking para a
modelagem de lgicas combinatrias mais complicadas onde a 3. Utilize process(all) para a modelagem de lgicas
declarao always til. combinatrias mais complicadas, onde process til. Utilize
atribuies blocking para variveis internas.
always_comb
begin process(all)
p = a ^ b; // blocking variable p, g: STD_LOGIC;
g = a & b; // blocking begin
s = p ^ cin; p := a xor b; blocking
cout = g | (p & cin); g := a and b; blocking
end s <= p xor cin;
end process;
284
4. No faa atribuies para o mesmo sinal em mais de uma

declarao always ou em declaraes de atribuio 4. No faa atribuies para a mesma varivel em mais de um
contnua. process ou em declaraes de atribuies concorrentes.
Lgica Combinatria*
O full adder do Figura 4.23 corretamente modelado utilizando-se atribuies blocking. Esta seo
explora como funciona, e como seria diferente se as atribuies nonblocking fossem utilizadas.
Imagine que a, b, e c possuem todos o valor inicial de 0. p, g, s e cout possuem, ento, tambm o
valor 0. Em algum momento, a muda para 1, disparando a declarao always/process. As quatro
atribuies blocking so avaliadas na ordem mostrada aqui (No cdigo VHDL, s e cout so declaradas
concorrentemente). Note que p e g recebem seus novos valores antes que s e cout sejam computados
devido s atribuies blocking. Isso importante pois ns queremos computar s e cout utilizando os
novos valores de p e g.
1. 10= 1
2. 10= 0
3. 10= 1
4. 0 + 1 0 = 0
Em contraste, a Figura 4.28 ilustra o uso de atribuies nonblocking.
Agora, considere o mesmo caso de uma mudana de 0 para 1 enquanto b e cin so 0. As quatro
atribuies nonblocking so computadas concorrentemente.
1 0 = 1; 1 0 = 0; 0 0 = 0; 0 + 0 0 = 0
285
Exemplo HDL 4.28 FULL ADDER UTILIZANDO ATRIBUIES NONBLOCKING
SystemVerilog VHDL
// nonblocking assignments (not recommended) nonblocking assignments (not recommended)

module fulladder(input logic a, b, cin, library IEEE; use IEEE.STD_LOGIC_1164.all;
output logic s, cout);
always_comb s, cout: out STD_LOGIC);
begin end;
p <= a ^ b; // nonblocking
g <= a & b; // nonblocking architecture nonblocking of fulladder is
s <= p ^ cin; signal p, g: STD_LOGIC;
cout <= g | (p & cin); begin
end process(all) begin
endmodule p <= a xor b; nonblocking
g <= a and b; nonblocking
s <= p xor cin;
end process;
end;
Devido a p e g aparecerem do lado esquerdo de uma atribuio

nonblocking numa declarao process, eles devem ser declarados
como signal ao invs de variable. A declarao signal
aparece antes de begin em architecture, no o process.
286
Observe que s computado concorrentemente com p e, consequentemente, utiliza o valor antigo de p,

no o novo. Portanto, s continua 0 ao invs de se tornar 1. No entanto, p muda de 0 para 1. Essa mudana
dispara a declarao always/process para computar uma segunda vez, como se segue:
1 0 = 1; 1 0 = 0; 1 0 = 1; 0 + 1 0 = 0
Desta vez, p j est com valor 1, ento s muda corretamente para 1. As atribuies nonblocking
eventualmente alcanam a resposta correta, mas a declarao always/process tem de ser
computada duas vezes. Isso torna a simulao lenta, embora ela sintetize o mesmo hardware.
Outra desvantagem das atribuies nonblocking na modelagem de lgica combinatria que o cdigo
HDL ir produzir o resultado errado se o leitor se esquecer de incluir as variveis intermedirias na lista
de sensibilidade.
Pior ainda, algumas ferramentas de sntese iro sintetizar corretamente o hardware mesmo quando
uma lista de sensibilidade falsa causar uma simulao incorreta. Isso leva a uma confuso entre os
resultados da simulao e o que o harware verdadeiramente faz.
SystemVerilog VHDL
Se a lista de sensibilidade da declarao always na Figura 4.28 fosse Se a lista de sensibilidade de process na Figura 4.28 fosse escrita
escrita como always @(a,b,cin) ao invs de always_comb, ento como process(a,b,cin) ao invs de process(all), ento a
a declarao poderia no computar novamente quando p ou g declarao poderia no computar novamente quando p ou g
mudassem de valor. Nesse caso, s poderia ser deixado incorreto como mudassem de valor. Nesse caso, s poderia ser deixado incorreto como
0, e no 1. 0, e no 1.
Lgica Sequencial*
O sincronizador da Figura 4.20 modelado corretamente utilizando declaraes nonblocking. Na
borda de subida do clock, d copiado para n1 ao mesmo tempo em que n1 copiado para q, ento o
287
cdigo descreve, apropriadamente, dois registradores. Por exemplo, suponha inicialmente que d = 0,
n1 = 1 e q = 0. Na borda de subida do clock, as duas atribuies seguintes ocorrem concorrentemente,
de modo que, aps a borda de clock, n1 = 0 e q = 1.
1 = 0; 1 = 1
O Figura 4.29 tenta descrever o mesmo mdulo utilizando atribuies nonblocking. No flanco
asncendente do clock, d copiado para n1. Ento o novo valor de n1 copiado para q, resultando em d
aparecendo, impropriamente, tanto em n1 como em q. As atribuies ocorrem uma aps a outra de
modo que, aps o flanco do clock, q=n1=0.
1. 1 = 0
2. 1 = 0
Exemplo HDL 4.29 MAU SINCRONIZADOR COM ATRIBUIES BLOCKING
SystemVerilog VHDL
// Bad implementation of a synchronizer using Bad implementation of a synchronizer using

blocking blocking
// assignments assignment
module syncbad(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic d,
output logic q); entity syncbad is
port(clk: in STD_LOGIC;
logic n1; d: in STD_LOGIC;
q: out STD_LOGIC);
always_ff @(posedge clk) end;
begin
n1 = d; // blocking architecture bad of syncbad is
q = n1; // blocking begin
end process(clk)
endmodule variable n1: STD_LOGIC;
begin
288
if rising_edge(clk) then
n1 := d; -- blocking
q <= n1;
end if;
end process;
end;
Figura 4.24 Circuito syncbad sintetizado
Devido a n1 ser invisvel para o mundo externo e no ter influncia no comportamento de q, o

sintetizador o otimiza inteiramente, como mostrado na Figura 4.24.
A moral dessa ilustrao a de utilizar atribuies nonblocking exclusivamente em declaraes
always/process quando modelar lgica sequencial. Com habilidade suficiente, com a inverso da
ordem das atribuies, voc pode fazer atribuies blocking funcionarem corretamente, mas atribuies
blocking no oferecem vantagens e apenas introduzem o risco de um comportamento incompreensvel.
Certos circuitos sequenciais no iro funcionar corretamente com atribuies blocking, no importa a
ordem.
4.6. MQUINAS DE ESTADOS FINITOS

Lembre-se que uma mquina de estados finitos (FSM) consiste num registrador de estado e dois blocos
de lgica combinatria para computar o prximo estgio e a sada, dados o estado atual e a entrada, como
mostrado na Figura 4.22. As descries HDL da mquinas de estado so correspondentemente divididas
em trs partes: a modelagem do registrador de estado, o prximo estado lgico, e a sada lgica.
289
Exemplo HDL 4.30 MQUINA DE ESTADO FINITA DIVIDIR POR 3
SystemVerilog VHDL
module divideby3FSM(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic reset,
output logic y); entity divideby3FSM is
typedef enum logic [1:0] {S0, S1, S2} port(clk, reset: in STD_LOGIC;
statetype; y: out STD_LOGIC);
statetype [1:0] state, nextstate; end;
// state register architecture synth of divideby3FSM is

always_ff @(posedge clk, posedge reset) type statetype is (S0, S1, S2);
if (reset) state <= S0; signal state, nextstate: statetype;
else state <= nextstate; begin
state register
// next state logic process(clk, reset) begin
always_comb if reset then state <= S0;
case (state) elsif rising_edge(clk) then
S0: nextstate <= S1; state <= nextstate;
S1: nextstate <= S2; end if;
S2: nextstate <= S0; end process;
default: nextstate <= S0;
endcase next state logic
nextstate <= S1 when state = S0 else
// output logic S2 when state = S1 else
assign y = (state = = S0); S0;
endmodule output logic
y <= '1' when state = S0 else '0';
A declarao typedef define statetype como sendo um valor do end;
tipo logic de dois bits com trs possibilidades: S0, S1 ou S2.
state e nexstate so sinais statetype. Este exemplo define um novo tipo de dado de enumerao, statetype,
com trs possiblidades: S0, S1 e S2. state e nextstate so
290
As codificaes padro enumeram a ordem numrica: S0=00, sinais statetype. Utilizando a enumerao ao invs de escolher a
S1=01, S2=10. As codificaes podem ser explicitamente definidas codificao do estado, a VHDL d liberdade ao sintetizador para
pelo usurio, no entanto, a ferramenta de sntese os vem como explorar vrias codificaes de estado at encontrar a melhor.
sugestes, no como requerimentos. Por exemplo, a parte de cdigo A sada, y, 1 quando o estado S0. A comparao de desigualdade
abaixo codifica os estados como valores de 3-bits one-hot: utiliza /=. Para produzir uma sada 1 quando o estado for qualquer
um, exceto S0, mude a comparao para state /= S0.
typedef enum logic [2:0] {S0 = 3'b001, S1 =
3'b010, S2 = 3'b100}
statetype;
Note como a declarao case utilizada para definir a tabela de

transio de estados. Como o prximo estado lgico deve ser
combinatrio, default necessrio, embora o estado 2b11
nunca deva mudar.
A sada, y, 1 quando o estado S0. A comparao de igualdade
a==b muda o valor para 1 se a igual a b, e 0 em qualquer outro
caso.
A comparao de desigualdade a!=b realiza o inverso, dando o valor
de 1 se a for diferente de b.
O Exemplo HDL 4.30 descreve a FMS diviso por 3 da Seo 3.4.2. Ela fornece um reset assncrono
para a inicializao da FSM. O registrador de estado utiliza a linguagem padro para flip-flops. O prximo
estado e a sada so combinatrios.
A ferramenta de sntese Synplify Premier apenas produz um diagrama de blocos e um diagrama de
transio de estados para mquinas de estado; ela no mostra as portas lgicas ou as entradas nos arcos
e estados. Portanto, tenha o cuidado de especificar corretamente a FSM no seu cdigo HDL. O diagrama
de transio de estados na Figura 4.25 para a FSM de diviso por 3 anlogo ao diagrama da Figura 3.28
(b). O crculo duplo indica que S0 o estado de reset. As implementaes a nvel de porta para a FSM de
diviso por 3 foram mostradas na Seo 3.4.2.
291
Figura 4.25 Circuito divideby3fsm sintetizado
Note que os estados so nomeados com um tipo de dado de enumerao, ao invs de nos referirmos
a eles em valores binrios. Isso deixa o cdigo mais legvel e mais fcil de mudar.
Se, por alguma razo, quisssemos que a sada fosse HIGH nos estados S0 e S1, a sada lgica seria
modificada como se segue.
SystemVerilog VHDL
// output logic output logic

assign y = (state = = S0 | state = = S1); y <= '1' when (state = S0 or state = S1) else
'0';
Os dois prximos exemplos de cdigo descrevem a FSM reconhecedora de padro de caracol,

mostrada na Seo 3.4.3. O cdigo mostra como utilizar declaraes case e if para lidar com prximos
estados e sadas lgicas que dependem tanto das entradas como dos estados atuais. Mostramos tanto
292
os mdulos de Mealey como de Moore. Na mquina de Moore (Exemplo HDL 4.31), a sada depende
apenas do estado atual, enquanto a mquina de Mealy (Exemplo HDL 4.32), a sada lgica depende tanto
dos estados atuais como das entradas.
Exemplo HDL 4.31 FSM DE MOORE RECONHECEDORA DE PADRO
SystemVerilog VHDL
module patternMoore(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic reset,
input logic a, entity patternMoore is
output logic y); port(clk, reset: in STD_LOGIC;
typedef enum logic [1:0] {S0, S1, S2} a: in STD_LOGIC;
statetype; y: out STD_LOGIC);
statetype state, nextstate; end;
// state register architecture synth of patternMoore is

always_ff @(posedge clk, posedge reset) type statetype is (S0, S1, S2);
state register
case (state) elsif rising_edge(clk) then state <=
S0: if (a) nextstate = S0; nextstate;
else nextstate = S1; end if;
S1: if (a) nextstate = S2; end process;
else nextstate = S1;
S2: if (a) nextstate = S0; next state logic
else nextstate = S1; process(all) begin
default: nextstate = S0; case state is
endcase when S0 =>
if a then nextstate <= S0;
else nextstate <= S1;
293
// output logic end if;

assign y = (state = = S2); when S1 =>
endmodule if a then nextstate <= S2;
Note como as atribuies nonblocking (<=) so utilizadas nos end if;
registradores de estados para descrever lgica sequencial, enquanto when S2 =>
as atribuies blocking (=) so utilizadas no estado lgico seguinte if a then nextstate <= S0;
para descrever lgica combinatria. else nextstate <= S1;
end if;
when others =>
nextstate <= S0;
end case;
end process;
output logic
y <= '1' when state = S2 else '0';
end;
Figura 4.26 Circuito patternMoore sintetizado
294
Exemplo HDL 4.32 FSM DE MEALY RECONHECEDORA DE PADRO
SystemVerilog VHDL
module patternMealy(input logic clk, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic reset,
input logic a, entity patternMealy is
output logic y); port(clk, reset: in STD_LOGIC;
a: in STD_LOGIC;
typedef enum logic {S0, S1} statetype; y: out STD_LOGIC);
statetype state, nextstate; end;
// state register architecture synth of patternMealy is

always_ff @(posedge clk, posedge reset) type statetype is (S0, S1);
state register
case (state) elsif rising_edge(clk) then state <=
S0: if (a) nextstate = S0; nextstate;
S1: if (a) nextstate = S0; end process;
else nextstate = S1;
default: nextstate = S0; next state logic
endcase process(all) begin
case state is
// output logic when S0 =>
assign y = (a & state = = S1); if a then nextstate <= S0;
endmodule else nextstate <= S1;
end if;
when S1 =>
if a then nextstate <= S0;
295

end if;
when others =>
nextstate <= S0;
end case;
end process;
output logic
y <= '1' when (a = '1' and state = S1) else
'0';
end;
Figura 4.27 Circuito patternMealy sintetizado
296
4.7. TIPOS DE DADOS*

Esta seo explica mais a fundo algumas sutilezas a respeito dos tipos de dados em VHDL e
SystemVerilog.
4.7.1. SystemVerilog
Anteriormente ao SystemVerilog, a Verilog primeiramente utilizava dois tipos: reg e wire. Apesar do
nome, um sinal reg pode ser ou no associado a um registrador. Isso era uma grande fonte de confuso
para aqueles que estavam aprendendo a linguagem.
SystemVerilog introduziu o tipo logic para eliminar a confuso; consequentemente, este livro
enfatiza o tipo logic. Esta seo explica os tipos reg e wire com mais detalhes para aqueles que
precisam ler algum velho cdigo Verilog.
Em Verilog, se um sinal aparece esquerda de <= ou = num bloco always, deve ser declarado como
reg. De outra forma, deveria ser declarado como wire. Consequentemente, um sinal reg pode ser a
sada de um flip-flop, bscula, ou lgica combinatria, dependendo da lista de sensibilidade e da declarao
de um bloco always.
Por padro, portas de entrada e de sada so do tipo wire, a no ser que sejam explicitamente
definidos como reg. O exemplo seguinte mostra como um flip-flop descrito em Verilog convencional.
Note que clk e d so, por padro, wire, enquanto q explicitamente definido como reg, pois aparece
esquerda de <= no bloco always.
module flop(input clk,
input [3:0] d,
output reg [3:0] q);
always @(posedge clk)
q <= d;
endmodule
297
A linguagem SystemVerilog introduz o tipo logc. logic um sinnimo para reg e evita enganos
sobre qual verdadeiramente um flip-flop. Mais ainda, SystemVerilog diminui as regras em declaraes
assign e em instanciaes hierrquicas de porta, de modo que logic pode ser utilizada fora de um
bloco always onde um wire tradicionalmente seria requerido. Assim, quase todos os sinais
SystemVerilog podem ser logic. A exceo que sinais com drivers mltiplos (por exemplo, um buffer
tristate) devem ser declarados como net, como descrito no Exemplo HDL 4.10. Essa regra permite
SystemVerilog gerar uma mensagem de erro ao invs de um valor x quando um sinal logic
acidentalmente conectado a mltiplos drivers.
O tipo mais comum de net chamado de wire ou tri. Estes dois tipos so sinnimos, mas wire
utilizado, convencionalmente, quando um nico driver est presente, e tri utilizado quando mltiplos
drivers esto presentes. Ento, wire est obsoleto em SystemVerilog, pois logic prefervel para sinais
com um nico driver.
Quando uma net tri levada a um mesmo valor por um ou mais drivers, ela assume aquele valor.
Quando no levada, ela flutua (z). Quando levada a um valor diferente (0, 1 ou x) por mltiplos drivers,
fica em conteno (x).
Existem outros tipos de nets que atuam de forma diferente quando no guiadas ou guiadas por
mltiplas fontes. Estes outros tipos so raramente utilizados, mas podem ser substituidos em qualquer
lugar em que uma net tri normalmente apareceria (por exemplo, para sinais com mltiplos drivers). Cada
um deles descrito na Tabela 4.7.
298
Tabela 4.7 Resolues de Nets
4.7.2. VHDL
Ao contrrio da SystemVerilog, a VHDL faz cumprir um rigoroso sistema de tipo de dados, que podem
proteger o usurio de alguns erros, mas que tambm desajeitado algumas vezes.
Apesar de ser de fundamental importncia, o tipo STD_LOGIG no construdo dentro da VHDL. Ao

invs disso, ele parte da biblioteca IEEE.STD_LOGIC_1164. Ento, todos os arquivos devem conter
as declaraes da biblioteca mostradas nos exemplos anteriores.
Mais ainda, a biblioteca IEEE.STD_LOGIC_1164 carece de operaes bsicas, como adio,

comparao, deslocamentos, e converso para dados inteiros STD_LOGIC_VECTOR. Eles foram
adicionados, finalmente, ao padro VHDL 2008, na biblioteca IEEE.NUMERIC_STD_UNSIGNED.
A linguagem VHDL tambm possui um tipo BOOLEAN com dois valores: true e false. Valores
BOOLEAN so retornados de comparaes (tais como comparaes de igualdade, s = 0) e so utilizados
em declaraes condicionais, tais como when e if. Apesar da tentao em acreditar que um valor
BOOLEAN true deve ser equivalente a um valor STD_LOGIC 1, e um BOOLEAN FALSE deve ser
equivalente a um STD_LOGIC 0, esses tipos no eram intercambiveis antes de VHDL 2008. Por exemplo,
num cdigo VHDL antigo, devemos escrever:
y <= d1 when (s = '1') else d0;
299
enquanto no VHDL 2008, a declarao when automaticamente converte s de STD_LOGIC para

BOOLEAN. Ento podemos escrever simplesmente:
y <= d1 when s else d0;
Mesmo no VHDL 2008, ainda necessrio escrever
q <= '1' when (state = S2) else '0';
ao invs de
q <= (state = S2);
pois (state = S2) retorna um resultado BOOLEAN, o qual no pode ser atribudo diretamente ao sinal
STD_LOGIC y.
Apesar de no declararmos quaisquer sinais para serem BOOLEAN, eles so automaticamente

indicados por comparaes e utilizados por declaraes condicionais. Similarmente, a VHDL tem um
tipo INTEGER que representa inteiros tanto positivos quanto negativos. Sinais do tipo INTEGER
abrangem os valores (231 1) a 231 1, pelo menos. Valores inteiros so utilizados como ndices de
barramentos. Por exemplo, na declarao:
y <= a(3) and a(2) and a(1) and a(0);
Os valores 0, 1, 2 e 3 so inteiros servindo como um ndice para a escolha de bits no sinal a. No

podemos indexar diretamente um barramento com um sinal STD_LOGIC ou STD_LOGIC_VECTOR.
Ao invs disso, devemos converter o sinal para um INTEGER. Isso demonstrado no exemplo abaixo
para um multiplexador 8:1 que seleciona um bit de um vetor utilizando um ndice de 3-bits. A funo
T0_INTEGER definida na biblioteca IEEE.NUMERIC_STD_UNSIGNED e realiza a converso de
valores positivos (sem sinal) de STD_LOGIC_VECTOR para INTEGER.
library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.NUMERIC_STD_UNSIGNED.all;
300
entity mux8 is
port(d: in STD_LOGIC_VECTOR(7 downto 0);
s: in STD_LOGIC_VECTOR(2 downto 0);
y: out STD_LOGIC);
end;
architecture synth of mux8 is

begin
y <= d(TO_INTEGER(s));
end;
A VHDL tambm rigorosa a respeito das portas out sendo utilizadas exclusivamente para sada. Por
exemplo, o seguinte cdigo para portas AND de duas e trs entradas ilegal em VHDL, pois v uma sada
e tambm utilizada para computar w.
library IEEE; use IEEE.STD_LOGIC_1164.all;
entity and23 is
v, w: out STD_LOGIC);
end;
architecture synth of and23 is

begin
v <= a and b;
w <= v and c;
end;
A VHDL define um tipo especial de porta, buffer, que resolve esse problema. Um sinal conectado a
uma porta buffer se comporta como uma sada, mas tambm pode ser utilizado dentro do mdulo. A
definio correta da entidade como se segue. Verilog e SystemVerilog no possuem essa limitao e
301
no necessitam de portas buffer. A VHDL 2008 eliminou essa restrio permitindo a portas out serem
legveis, mas essa mudana no suportada pela ferramenta CAD Synplify at ao momento da escrita deste
livro.
entity and23 is
v: buffer STD_LOGIC;
w: out STD_LOGIC);
end;
Figura 4.28 Circuito and23 sintetizado
A maioria das operaes, como adio, subtrao e lgica Booleana so idnticas se um nmero possui
ou no sinal. No entanto, a comparao de magnitude, a multiplicao e deslocamentos aritmticos
direita so executadas de forma diferente em nmeros com sinal em complemento-2. Estas operaes
sero examinadas no Captulo 5. O Exemplo HDL 4.33 descreve como indicar que um nmero possui sinal.
Exemplo HDL 4.33 (A) MULTIPLICADOR SEM SINAL (B) MULTIPLICADOR COM SINAL
SystemVerilog VHDL
// 4.33(a): unsigned multiplier 4.33(a): unsigned multiplier

module multiplier(input logic [3:0] a, b, library IEEE; use IEEE.STD_LOGIC_1164.all;
output logic [7:0] y); use IEEE.NUMERIC_STD_UNSIGNED.all;
assign y = a * b;
302
endmodule entity multiplier is

port(a, b: in STD_LOGIC_VECTOR(3 downto 0);
// 4.33(b): signed multiplier y: out STD_LOGIC_VECTOR(7 downto 0));
module multiplier(input logic signed [3:0]
a,b, end;
output logic signed [7:0]
y); architecture synth of multiplier is
begin
assign y = a * b; y <= a * b;
endmodule end;
Em SystemVerilog, os sinais so considerados sem sinal por padro. A VHDL utiliza a biblioteca NUMERIC_STD_UNSIGNED para realizar
Adicionando o modificador signed (logic signed [3:0] a), operaes aritmticas e de comparao em STD_LOGIC_VECTOR.
o sinal ento tratado como possuindo sinal. Os vetores so tratados como no possuindo sinal.
A VHDL tambem define os tipos de dados UNSIGNED e SIGNED na

biblioteca IEEE.NUMERIC_STD, mas isso envolve converses de
tipos de dados que esto alm do escopo deste Captulo.
303
4.8. MDULOS PARAMETRIZADOS*

At agora, todos os nossos mdulos tiveram entradas e sadas de tamanho fixo. Por exemplo,
tivemos de definir mdulos separados para multiplexadores 2:1 de 4-bits e 8-bits de largura. As HDL
permitem a utilizao de bits de tamanhos variveis utilizando-se mdulos parametrizados.
O Exemplo HDL 4.34 declara um multiplexador 2:1 parametrizado com um tamanho padro de 8,
ento utiliza-o para criar multiplexadores 4:1 de 8- e 12-bits.
Exemplo HDL 4.34 MULTIPLEXADORES 2:1 PARAMETRIZADOS DE N-BITS
SystemVerilog VHDL
module mux2 library IEEE; use IEEE.STD_LOGIC_1164.all;

#(parameter width = 8)
(input logic [width1:0] d0, d1, entity mux2 is
input logic s, generic(width: integer := 8);
output logic [width1:0] y); port(d0,
d1: in STD_LOGIC_VECTOR(width1 downto 0);
assign y = s ? d1 : d0; s: in STD_LOGIC;
endmodule y: out STD_LOGIC_VECTOR(width1 downto 0));
end;
A SystemVerilog permite uma declarao #(parameter...) antes
das entadas e sadas para definir parmetros. A declarao architecture synth of mux2 is
parameter inclui um valor padro (8) do parmetro, nesse caso, begin
chamado width. O nmero de bits nas entradas e nas sadas y <= d1 when s else d0;
end;
dependem desse parmetro.
A declarao generic inclui um valor padro (8) para width. Esse
module mux4_8(input logic [7:0] d0, d1, d2,
d3, valor um inteiro.
304

output logic [7:0] y); library IEEE; use IEEE.STD_LOGIC_1164.all;
logic [7:0] low, hi; entity mux4_8 is
mux2 lowmux(d0, d1, s[0], low); port(d0, d1, d2,
mux2 himux(d2, d3, s[0], hi); d3: in STD_LOGIC_VECTOR(7 downto 0);
mux2 outmux(low, hi, s[1], y); s: in STD_LOGIC_VECTOR(1 downto 0);
end;
O multiplexador 4:1 de 8-bits instancia trs multiplexadores 2:1
utilzando seus tamanhos padro. architecture struct of mux4_8 is
Em contraste, um multiplexador 4:1 de 12-bits, mux4_12, necessitaria component mux2
sobrepor o tamanho padro utilizando #() antes do nome da generic(width: integer := 8);
instncia, como mostrado abaixo. port(d0,
d1: in STD_LOGIC_VECTOR(width-1 downto
module mux4_12(input logic [11:0] d0, d1, d2, 0);
d3, s: in STD_LOGIC;
input logic [1:0] s, y: out STD_LOGIC_VECTOR(width-1 downto
output logic [11:0] y); 0));
logic [11:0] low, hi; end component;
signal low, hi: STD_LOGIC_VECTOR(7 downto 0);
mux2 #(12) lowmux(d0, d1, s[0], low); begin
mux2 #(12) himux(d2, d3, s[0], hi); lowmux: mux2 port map(d0, d1, s(0), low);
mux2 #(12) outmux(low, hi, s[1], y); himux: mux2 port map(d2, d3, s(0), hi);
endmodule outmux: mux2 port map(low, hi, s(1), y);
end;
No confunda o uso de #sinal indicando atrasos, com o uso de
O multiplexador 4:1 de 8-bits, mux4_8, instancia trs multiplexadores
#(...) na definio de sobreposio de parmetros.
2:1 utilizando seus tamanhos padro.
Em contraste, um multiplexador 4:1 de 12 bits, mux4_12, necessitaria
da sobreposio do tamanho padro utilizando-se generic map,
como mostrado abaixo.
lowmux: mux2 generic map(12)

port map(d0, d1, s(0), low);
305
himux: mux2 generic map(12)

port map(d2, d3, s(0), hi);
outmux: mux2 generic map(12)
port map(low, hi, s(1), y);
Figura 4.29 Circuito mux4_12 sintetizado
Exemplo HDL 4.35 DECODIFICADOR PARAMETRIZADO : 2
SystemVerilog VHDL
module decoder library IEEE; use IEEE.STD_LOGIC_1164.all;

#(parameter N = 3) use IEEE. NUMERIC_STD_UNSIGNED.all;
(input logic [N1:0] a,
306
output logic [2**N1:0] y); entity decoder is

generic(N: integer := 3);
always_comb port(a: in STD_LOGIC_VECTOR(N1 downto 0);
begin y: out STD_LOGIC_VECTOR(2**N1 downto
y = 0; 0));
y[a] = 1; end;
end
endmodule architecture synth of decoder is
begin
2**N indica 2 . process(all)
begin
y <= (OTHERS => '0');
y(TO_INTEGER(a)) <= '1';
end process;
end;
2**N indica 2 .
307
O Exemplo HDL 4.35 mostra um decodificador , o qual uma aplicao ainda melhor dos mdulos
parametrizados. Um grande decodificador : 2 complicado de se especificar em declaraes case,
mas simples utilizando-se um cdigo parametrizado que simplesmente leve o bit de sada apropriado
para 1. Especificamente, o decodificador utiliza atribuies blocking para colocar todos os bits a 0, e de
seguida muda os bits apropriados para 1.
As HDL tambm fornecem declaraes generate para produzir uma quantidade varivel de
hardware, dependendo do valor de um parmetro. generate suporta loops for e declaraes if
para determinar quantos de quais tipos de hardware produzir. O Exemplo HDL 4.36 demonstra como
utilizar declaraes generate para produzir uma funo AND de N entradas a partir de portas AND de
duas entradas em cascata. claro, um operador de reduo seria mais limpo e mais simples para essa
aplicao, mas o exemplo ilustra o princpio geral dos geradores de hardware.
Use declaraes generate com cautela; fcil produzir uma grande quantidade de hardware
involuntariamente!
Exemplo HDL 4.36 PORTA AND PARAMETRIZADA DE N ENTRADAS
SystemVerilog VHDL
module andN library IEEE; use IEEE.STD_LOGIC_1164.all;

#(parameter width = 8)
(input logic [width1:0] a, entity andN is
output logic y); generic(width: integer := 8);
port(a: in STD_LOGIC_VECTOR(width1 downto
genvar i; 0);
logic [width1:0] x; y: out STD_LOGIC);
end;
generate
assign x[0] = a[0]; architecture synth of andN is
for(i=1; i<width; i=i+1) begin: forloop signal x: STD_LOGIC_VECTOR(width1 downto 0);
assign x[i] = a[i] & x[i1]; begin
308
end x(0) <= a(0);

gen: for i in 1 to width-1 generate
endgenerate x(i) <= a(i) and x(i-1);
assign y = x[width1]; end generate;
endmodule y <= x(width1);
end;
A declarao for se repete atravs de i = 1, 2, ..., width
1 para produzir muitas portas AND consecutivas. O begin num A varivel geradora de loop, i, no precisa ser declarada.
loop for generate deve ser seguido por um : e um rtulo
arbitrrio (forloop, nesse caso).
Figura 4.30 Circuito andN sintetizado
309
4.9. TESTBENCHES
Um testbench (bancada de testes, em portugus) um mdulo que utilizado para testar outro
Algumas ferramentas tambm mdulo, chamado de dispositivo sob teste (device under test, DUT). O testbench contm declaraes
chamam o mdulo a ser testado a para aplicar entradas ao DUT e, idealmente, verificar se as sadas corretas so produzidas. Os padres
unidade em ensaio ou unit under test de entrada e de sada desejados so chamados de vetores de teste.
(UUT).
Considere o teste do mdulo sillyfunction, da Seo 4.1.1, que computa a equao = +
+ . Esse um mdulo simples, ento ns podemos realizar testes exaustivos aplicando-se oito
possveis vetores de teste.
Exemplo HDL 4.37 TESTBENCH
SystemVerilog VHDL
module testbench1(); library IEEE; use IEEE.STD_LOGIC_1164.all;

logic a, b, c, y; entity testbench1 is -- no inputs or outputs
end;
// instantiate device under test
sillyfunction dut(a, b, c, y); architecture sim of testbench1 is
component sillyfunction
// apply inputs one at a time port(a, b, c: in STD_LOGIC;
initial begin y: out STD_LOGIC);
a = 0; b = 0; c = 0; #10; end component;
c = 1; #10; signal a, b, c, y: STD_LOGIC;
b = 1; c = 0; #10; begin
c = 1; #10; instantiate device under test
a = 1; b = 0; c = 0; #10; dut: sillyfunction port map(a, b, c, y);
c = 1; #10; apply inputs one at a time
b = 1; c = 0; #10; process begin
c = 1; #10; a <= '0'; b <= '0'; c <= '0'; wait for 10
end ns;
endmodule c <= '1'; wait for 10 ns;
b <= '1'; c <= '0'; wait for 10 ns;
310
A declarao initial executa a declarao em seu corpo no incio c <= '1'; wait for 10 ns;
da simulao. Nesse caso, ela aplica o padro de entrada 000 e a <= '1'; b <= '0'; c <= '0'; wait for 10
aguarda 10 unidades de tempo. Ela ento aplica 001 e aguarda mais ns;
10 unidades, e assim por diante, at todas as oito possveis entradas c <= '1'; wait for 10 ns;
b <= '1'; c <= '0'; wait for 10 ns;
terem sido aplicadas. Declaraes initial devem ser utilizadas
c <= '1'; wait for 10 ns;
apenas em testbenchs para simulao, no em mdulos que sero
wait; wait forever
sintetizados em hardware de verdade. O hardware no possui um end process;
modo mgico de executar uma sequncia de passos especiais quando end;
ligado.
A declarao process aplica, primeiramente, o padro de entrada
000 e, ento, aguarda 10 ns. Ela ento aplica 001 e aguarda por mais
10 ns, e assim sucessivamente at que todas as oito possveis entradas
tenham sido aplicadas.
No final, o processo aguarda indefinidamente. De outro modo, ele
comearia novamente, aplicando repetidamente o padro de vetores
de teste.
Exemplo HDL 4.38 TESTBENCH AUTO-VERIFICVEL

SystemVerilog VHDL

logic a, b, c, y;
// instantiate device under test entity testbench2 is no inputs or outputs
sillyfunction dut(a, b, c, y); end;
// apply inputs one at a time
// checking results architecture sim of testbench2 is
initial begin component sillyfunction
a = 0; b = 0; c = 0; #10; port(a, b, c: in STD_LOGIC;
311
assert (y === 1) else $error("000 failed."); y: out STD_LOGIC);

c = 1; #10; end component;
assert (y === 0) else $error("001 failed."); signal a, b, c, y: STD_LOGIC;
b = 1; c = 0; #10; begin
assert (y === 0) else $error("010 failed."); instantiate device under test
c = 1; #10; dut: sillyfunction port map(a, b, c, y);
assert (y === 0) else $error("011 failed."); apply inputs one at a time
a = 1; b = 0; c = 0; #10; checking results
assert (y === 1) else $error("100 failed."); process begin
c = 1; #10; a <= '0'; b <= '0'; c <= '0'; wait for 10 ns;
assert (y === 1) else $error("101 failed."); assert y = '1' report "000 failed.";
b = 1; c = 0; #10; c <= '1'; wait for 10 ns;
c = 1; #10; b <= '1'; c <= '0'; wait for 10 ns;
end c <= '1'; wait for 10 ns;
endmodule assert y = '0' report "011 failed.";
a <= '1'; b <= '0'; c <= '0'; wait for 10 ns;
A instruo assert do SystemVerilog verifica se uma condio assert y = '1' report "100 failed.";
especificada verdadeira. Se no for, ele executa a instruo else. A c <= '1'; wait for 10 ns;
tarefa do $error na declarao else imprime uma mensagem de assert y = '1' report "101 failed.";
erro que descreve a falha de declarao. Durante a sntese assert b <= '1'; c <= '0'; wait for 10 ns;
assert y = '0' report "110 failed.";
ignorada. Em SystemVerilog, a comparao com == ou!= eficaz
c <= '1'; wait for 10 ns;
entre os sinais que no tomam valores de x e z. Testbenches usam os assert y = '0' report "111 failed.";
operadores === e !== para comparar igualdade e desigualdade, wait; wait forever
respectivamente, dado que esses operadores funcionam end process;
corretamente com operandos que podem ser x ou z. end;
A instruo assert verifica uma condio e imprime a mensagem

dada na clusula report se a condio no for satisfeita. assert
significativa apenas na simulao, e no na sntese.
312
O Exemplo HDL 4.37 demonstra um testbench simples. Ela instancia o DUT, ento aplica as entradas.
Atribuies blocking e delays so utilizadas para aplicar as entradas na ordem apropriada. O usurio deve
visualizar os resultados da simulao e verificar, por inspeo, se a sada correta foi produzida. Testbenches
so simuladas da mesma forma em outros mdulos HDL. No entando, elas no so sintetizveis.
Verificar as sadas corretas um trabalho tedioso e propenso a erros. Mais ainda, determinar as sadas
corretas muito mais fcil quando o projeto est ainda fresco na sua mente. Se voc fizer pequenas
mudanas e precisar testar o projeto novamente semanas depois, determinar as sadas corretas se torna
um aborrecimento. Uma abordagem muito melhor escrever um testbench auto-checvel, mostrado no
Exemplo HDL 4.38.
Escrever um cdigo para cada vetor de testes tambm se torna tedioso, especialmente para mdulos
que requerem um nmero muito grande de vetores. Uma abordagem melhor colocar os vetores num
arquivo separado. O testbench l os vetores de teste do arquivo, aplica o vetor de teste de entrada ao DUT,
espera, verifica se os valores de sada do DUT so iguais aos do vetor de sada, e repete o processo at
alcanar o fim do arquivo de vetores de teste.
O Exemplo HDL 4.39 demonstra tal testbench. O testbench gera um clock utilizando uma declarao
always/process sem lista de sensibilidade, ento continuamente reavaliada. Ao incio da simulao,
ela l os vetores de teste a partir de um arquivo texto e pulsa o reset por dois ciclos. Apesar de o clock e do
reset no serem necessrios para testar a lgica combinatria, eles so includos, pois podem ser
importantes para testar um DUT sequencial. O example.tv um arquivo texto que contm as entradas
e os valores esperados de sada, em binrio:
000_1
001_0
010_0
011_0
100_1
101_1
110_0
111_0
313
Exemplo HDL 4.39 TESTBENCH COM ARQUIVO DE VETOR DE TESTES
SystemVerilog VHDL

logic clk, reset; use IEEE.STD_LOGIC_TEXTIO.ALL; use
logic a, b, c, y, yexpected; STD.TEXTIO.all;
logic [31:0] vectornum, errors;
logic [3:0] testvectors[10000:0]; entity testbench3 is no inputs or outputs
end;
// instantiate device under test
sillyfunction dut(a, b, c, y); architecture sim of testbench3 is
// generate clock component sillyfunction
always port(a, b, c: in STD_LOGIC;
begin y: out STD_LOGIC);
clk = 1; #5; clk = 0; #5; end component;
end signal a, b, c, y: STD_LOGIC;
signal y_expected: STD_LOGIC;
// at start of test, load vectors signal clk, reset: STD_LOGIC;
// and pulse reset begin
initial instantiate device under test
begin dut: sillyfunction port map(a, b, c, y);
$readmemb("example.tv", testvectors);
vectornum = 0; errors = 0; generate clock
reset = 1; #27; reset = 0; process begin
end clk <= '1'; wait for 5 ns;
clk <= '0'; wait for 5 ns;
// apply test vectors on rising edge of clk end process;
begin at start of test, pulse reset
#1; {a, b, c, yexpected} = process begin
testvectors[vectornum]; reset <= '1'; wait for 27 ns; reset <= '0';
wait;
314
end end process;
// check results on falling edge of clk run tests

always @(negedge clk) process is
if (~reset) begin // skip during reset file tv: text;
if (y ! == yexpected) begin // check result variable L: line;
$display("Error: inputs = %b", {a, b, c}); variable vector_in: std_logic_vector(2
$display(" outputs = %b (%b expected)", y,
yexpected);
downto 0);
errors = errors + 1; variable dummy: character;
end variable vector_out: std_logic;
vectornum = vectornum + 1; variable vectornum: integer := 0;
if (testvectors[vectornum] === 4'bx) begin variable errors: integer := 0;
$display("%d tests completed with %d begin
errors", FILE_OPEN(tv, "example.tv", READ_MODE);
vectornum, errors); while not endfile(tv) loop
$finish;
end change vectors on rising edge
end
wait until rising_edge(clk);
endmodule
read the next line of testvectors and
$readmemb carrega um arquivo de nmeros binrios num array de split into pieces
testvectors. $readmemh tem uma funo similar, mas para readline(tv, L);
nmeros hexadecimais. read(L, vector_in);
O bloco seguinte de cdigo espera uma unidade de tempo aps o read(L, dummy); skip over underscore
flanco ascendente do relgio (para evitar qualquer confuso se o clock read(L, vector_out);
e os dados mudarem simultaneamente), ento as trs entradas (a, b (a, b, c) <= vector_in(2 downto 0) after 1
e c) so activas e a sada esperada (yexpected), baseado nos quatro ns;
bits do vetor de testes atual. y_expected <= vector_out after 1 ns;
O tesbench compara a sada gerada, y, com a sada esperada,
check results on falling edge
yexpected, e imprime um erro se eles no forem iguais. %b e %d
wait until falling_edge(clk);
indicam se o valor impresso em binrio e hexadecimal,
respectivamente. $display uma tarefa do sistema para imprimir if y /= y_expected then
o valor na tela do simulador. Por exemplo, $display(%b %b, report "Error: y = " & std_logic'image(y);
errors := errors + 1;
315
y, yexpected) imprime os dois valores, y e yexpected, em end if;

binrio. %h imprime o valor em hexadecimal.
Este processo repetido at no haver mais vetores de teste vlidos vectornum := vectornum + 1;
no array testvectors. $finish encerra a simulao. end loop;
Note que, mesmo que o SystemVerilog suporte at 10.001 vetores de
summarize results at end of simulation
teste, ele encerra a simulao depois de ter executado os oito vetores if (errors = 0) then
no arquivo. report "NO ERRORS -- " &
integer'image(vectornum) &
" tests completed successfully."
severity failure;
else
report integer'image(vectornum) &
" tests completed, errors = " &
integer'image(errors)
severity failure;
end if;
end process;
end;
O cdigo VHDL utiliza comandos de leitura de arquivos que vo alm

do escopo desse Captulo, mas esse exemplo d a sensao do que
um tesbench auto-verificvel parece em VHDL.
Novas entradas so aplicadas no flanco ascendente do relgo, e a sada verificada no flanco

descendente. Os erros so reportados assim que ocorrem. Ao fim da simulao, o testbench imprime o
nmero total de vetores de teste aplicados e o nmero de erros detectados.
O testbench do Exemplo HDL 4.39 exagerada para um circuito to simples. No entanto, ele pode
ser facilmente modificado para testar circuitos mais complexos mudando o arquivo example.tv,
instanciando o novo DUT, e mudando algumas linhas de cdigo para ativar as entradas e verificar as
sadas.
316
4.10. SUMRIO
Linguagens de descrio de hardware (HDL) so ferramentas extremamente importantes para
projetistas de sistemas digitais modernos. Uma vez que o leitor tenha aprendido SystemVerilog ou VHDL,
ser capaz de especificar sistemas digitais muito mais rpido do que se tivesse que desenhar os
esquemticos completos. O ciclo de debug tambm muito mais rpido, pois as modificaes requerem
mudanas de cdigo, ao invs de tediosas religaes no esquemtico. No entanto, o ciclo de debug pode
ser muito mais longo utilizando-se HDL, se o leitor no tiver uma boa ideia a respeito do hardware que o
seu cdigo implica.
As HDL so utilizadas tanto para simulao quanto para sntese. A simulao lgica um modo poderoso
de testar um sistema num computador antes de transform-lo em hardware. Os simuladores permitem ao
leitor verificar os valores dos sinais internos ao seu sistema, que seriam impossveis de medir numa
implementao fsica de hardware. A sntese lgica converte cdigo em circuitos lgicos digitais.
A coisa mais importante a lembrar quando se est escrevendo um cdigo HDL que o leitor est
descrevendo hardware real, e no escrevendo um programa de computador. O erro mais comum de
iniciantes escrever o cdigo HDL sem pensar direito a respeito do hardware que se quer produzir. Se voc
no conhece o hardware que est pretendendo ter, esteja quase certo de no conseguir o que quer. Ao
invs disso, comee esboando um diagrama de blocos do seu sistema, identificando quais pores so de
lgica combinatria, quais pores so circuitos sequenciais ou mquinas de estado finitas, e assim por
diante. Ento, escreva o cdigo HDL para cada poro, utilizando as linguagens corretas para indicar o tipo
de hardware que o leitor precisa.
317
Exerccios
Os exerccios seguintes podem ser feitos utilizando a sua HDL favorita. Se o leitor tem um simulador
disponvel, teste o seu projeto. Imprima as formas de onda e explique como pode provar que o circuito
funciona. Se possuir um sintetizador disponvel, sintetize o cdigo. Imprima o diagrama do circuito
gerado, e explique porque ele atende s suas expectativas.
Exerccio 4.1 Esboce o esquemtico do circuito descrito pelo seguinte cdigo HDL. Simplifique o
esquemtico para que ele tenha um nmero mnimo de portas lgicas.
SystemVerilog VHDL
module exercise1(input logic a, b, c, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic y, z);
assign y = a & b & c | a & b & ~c | a & ~b & entity exercise1 is
c; port(a, b, c: in STD_LOGIC;
assign z = a & b | ~a & ~b; y, z: out STD_LOGIC);
endmodule end;
architecture synth of exercise1 is

begin
y <= (a and b and c) or (a and b and not c)
or (a and not b and c);
z <= (a and b) or (not a and not b);
end;
Exerccio 4.2 Esboce o esquemtico do circuito descrito pelo seguinte cdigo HDL. Simplifique o
esquemtico para que ele tenha um nmero mnimo de portas lgicas.
318
SystemVerilog VHDL
module exercise2(input logic [3:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;

always_comb entity exercise2 is
if (a[0]) y = 2'b11; port(a: in STD_LOGIC_VECTOR(3 downto 0);
else if (a[1]) y = 2'b10; y: out STD_LOGIC_VECTOR(1 downto 0));
else if (a[2]) y = 2'b01; end;
else if (a[3]) y = 2'b00;
else y = a[1:0]; architecture synth of exercise2 is
endmodule begin
process(all) begin
if a(0) then y <= "11";
elsif a(1) then y <= "10";
else y <= a(1 downto 0);
end if;
end process;
end;
Exerccio 4.3 Escreva um mdulo HDL que compute uma funo XOR de quatro entradas. A entrada
3:0 , e a sada .
Exerccio 4.4 Escreva um tesbench auto-verificvel para o Exerccio 4.3. Crie um arquivo vetor de testes
contendo todos os 16 casos de teste. Simule o circuito e mostre que ele funciona. Introduza um erro
no arquivo de vetor de testes e mostre que o tesbench reporta uma incompatibilidade.
319
Exerccio 4.5 Escreva um mdulo HDL chamado minority. Ele recebe trs entradas, a, b e c, e
produz uma sada, y, que TRUE se ao menos duas das entradas so FALSE.
Exerccio 4.6 Escreva um mdulo HDL para um decodificador de display de sete segmentos
hexadecimal. O decodificador deve lidar com os dgitos A, B, C, D, E e F, assim como de 0 a 9.
Exerccio 4.7 Escreva um tesbench auto-verificvel para o Exerccio 4.6. Crie um arquivo vetor de testes
contendo todos os 16 casos de teste. Simule o circuito e mostre que ele funciona. Introduza um erro no
arquivo de vetor de testes e mostre que a tesbench reporta uma incompatibilidade.
Exerccio 4.8 Escreva um mdulo multiplexador 8:1 chamado mux8 com entradas
2:0 , 0, 1, 2, 3, 4, 5, 6, 7, e a sada .
Exerccio 4.9 Escreva um mdulo estrutural para computar a funo lgica = + + ,

utilizando lgica de multiplexadores. Utilize o multiplexador do Exerccio 4.8.
Exerccio 4.10 Repita o Exerccio 4.9 utilizando um multiplexador 4:1 e quantas portas NOT forem
necessrias.
Exerccio 4.11 Na Seo 4.5.4 foi mostrado que um sincronizador pode ser descrito corretamente com
atribuies blocking, se as atribuies forem dadas na ordem apropriada. Pense num circuito sequencial
simples que no possa ser descrito corretamente com atribuies blocking, independentemente da
ordem.
320
Exerccio 4.12 Escreva um mdulo HDL para um circuito prioridade de oito entradas.
Exerccio 4.13 Escreva um mdulo HDL para um decodificador 2:4.
Exerccio 4.14 Escreva um mdulo HDL para um decodificador 6:64 utilizando trs instncias de
decodificadores 2:4 do Exerccio 4.13 e um grupo de portas AND de trs entradas.
Exerccio 4.15 Escreva um mdulo HDL que implemente as equaes Booleanas do Exerccio 2.13.
Exerccio 4.16 Escreva um mdulo HDL que implemente o circuito do Exerccio 2.26.
Exerccio 4.17 Escreva um mdulo HDL que implemente o circuito do Exerccio 2.27.
Exerccio 4.18 Escreva um mduo HDL que implemente a funo lgica do Exerccio 2.28. Preste muita
ateno no modo como lida com os dont cares.
Exerccio 4.19 Escreva um mdulo HDL que implemente as funes do Exerccio 2.35.
Exerccio 4.20 Escreva um mdulo HDL que implemente o codificador de prioridade do Exerccio 2.36.
321
Exerccio 4.21 Escreva um mdulo HDL que implemente o codificador de prioridade modificado do
Exerccio 2.37.
Exerccio 4.22 Escreva um mdulo HDL que implemente o cdigo binrio para termmetro do Exerccio
2.38.
Exerccio 4.23 Escreva um mdulo HDL implementando a funo dias no ms da questo 2.2.
Exerccio 4.24 Esboce o diagrama de transio de estados para a FSM descrita pelo cdigo abaixo.
SystemVerilog VHDL
module fsm2(input logic clk, reset, library IEEE; use IEEE.STD_LOGIC_1164.all;

input logic a, b,
output logic y); entity fsm2 is
logic [1:0] state, nextstate; port(clk, reset: in STD_LOGIC;
a, b: in STD_LOGIC;
parameter S0 = 2'b00; y: out STD_LOGIC);
parameter S1 = 2'b01; end;
parameter S2 = 2'b10;
parameter S3 = 2'b11; architecture synth of fsm2 is
type statetype is (S0, S1, S2, S3);
always_ff @(posedge clk, posedge reset) signal state, nextstate: statetype;
if (reset) state <= S0; begin
else state <= nextstate; process(clk, reset) begin
if reset then state <= S0;
always_comb elsif rising_edge(clk) then
case (state) state <= nextstate;
S0: if (a ^ b) nextstate = S1; end if;
else nextstate = SO;
322
S1: if (a & b) nextstate = S2; end process;

else nextstate = SO;
S2: if (a | b) nextstate = S3; process(all) begin
else nextstate = SO; case state is
S3: if (a | b) nextstate = S3; when S0 => if (a xor b) then
else nextstate = SO; nextstate <= S1;
endcase else nextstate <= S0;
assign y = (state = = S1) | (state = = S2); end if;
endmodule when S1 => if (a and b) then
nextstate <= S2;
end if;
when S2 => if (a or b) then
nextstate <= S3;
end if;
when S3 => if (a or b) then
nextstate <= S3;
end if;
end case;
end process;
y <= '1' when ((state = S1) or (state = S2))

else '0';
end;
Exerccio 4.25 Esboce o diagrama de transio de estados para a FSM descrita pelo seguinte cdigo
HDL. Uma FSM desta natureza utilizada num ramo preditor em alguns microprocessadores.
323
SystemVerilog VHDL
module fsm1(input logic clk, reset, library IEEE; use IEEE.STD_LOGIC_1164. all;
input logic taken, back,
output logic predicttaken); entity fsm1 is
port(clk, reset: in STD_LOGIC;
logic [4:0] state, nextstate; taken, back: in STD_LOGIC;
predicttaken: out STD_LOGIC);
parameter S0 = 5'b00001; end;
parameter SI = 5'b00010;
parameter S2 = 5'b00100; architecture synth of fsm1 is
parameter S3 = 5'b01000; type statetype is (S0, S1, S2, S3, S4);
parameter S4 = 5'b10000; signal state, nextstate: statetype;
begin
always_ff @(posedge clk, posedge reset) process(clk, reset) begin
if (reset) state <= S2; if reset then state <= S2;
else state <= nextstate; elsif rising_edge(clk) then
state <= nextstate;
always_comb end if;
case (state) end process;
S0: if (taken) nextstate = S1; process(all) begin
else nextstate = S0; case state is
S1: if (taken) nextstate = S2; when S0 => if taken then
else nextstate = S0; nextstate <= S1;
S2: if (taken) nextstate = S3; else nextstate <= S0;
S3: if (taken) nextstate = S4; when S1 => if taken then
else nextstate = S2; nextstate => S2;
S4: if (taken) nextstate = S4; else nextstate <= S0;
default: nextstate = S2; when S2 => if taken then
endcase nextstate <= S3;
assign predicttaken = (state = = S4) | end if;
(state = = S3) | when S3 => if taken then
324
(state = = S2 && back); nextstate <= S4;

endmodule else nextstate <= S2;
end if;
when S4 => if taken then
nextstate <= S4;
end if;
when others => nextstate <= S2;
end case;
end process;
output logic
predicttaken <= '1' when
((state = S4) or (state = S3) or
(state = S2 and back = '1'))
else '0';
end;
Exerccio 4.26 Escreva um mdulo HDL para uma bscula SR.
Exerccio 4.27 Escreva um mdulo HDL para um flip-flop JK. O flip-flop possui entradas, clk, J, K, e a
sada Q. No flanco ascendente do relgio, Q mantm o antigo valor se J=K=0. Ele ativa 1 em Q se J=1,
limpa Q para 0 se K=1, e inverte Q se J=K=1.
Exerccio 4.28 Escreva um mdulo HDL para a bscula da Figura 3.18. Utilize uma declarao de
atribuio para cada porta. Especifique atrasos de 1 unidade de tempo ou 1 ns por porta. Simule a bscula
325
e mostra que ela opera corretamente. Em seguida, aumente o atraso do inversor. O quo grande o atraso
necessita ser, antes que uma condio de corrida cause o mau funcionamento da bscula?
Exerccio 4.29 Escreva um mdulo HDL para o controlador do semforo da Seo 3.4.1
Exerccio 4.30 Escreva trs mdulos HDL para o factoring do controlador de semforo em modo de
parada do exemplo 3.8. Os mdulos podem ser chamados de controlador, modo e luzes, e eles devem
ter as entradas e as sadas como mostrado na Figura 3.33 (b).
Exerccio 4.31 Escreva um mdulo HDL descrevendo o circuito na Figura 3.42.
Exerccio 4.32 Escreva um mdulo HDL para a FSM com o diagrama de transio de estados dado na
Figura 3.69 do Exerccio 3.22.
Exerccio 4.33 Escreva um mdulo HDL para a FSM com o diagrama de transio de estados dado na
Figura 3.70 do Exerccio 3.23.
Exerccio 4.34 Escreva um mdulo HDL para o controlador melhorado do semforo do Exerccio 3.24.
Exerccio 4.35 Escreva um mdulo HDL para o caracol do Exerccio 3.25.
Exerccio 4.36 Escreva um mdulo HDL para a mquina de refrigerantes do Exerccio 3.26
326
Exerccio 4.37 Escreva um mdulo HDL para o contador de cdigo Gray do Exerccio 3.27.
Exerccio 4.38 Escreva um mdulo HDL para o contador de cdigo Gray UP/DOWN do Exerccio 3.28.
Exerccio 4.39 Escreva um mdulo HDL para a FSM do Exerccio 3.29.
Exerccio 4.40 Escreva um mdulo HDL para a FSM do Exerccio 3.30.
Exerccio 4.41 Escreva um mdulo HDL para a srie complemento-2 da questo 3.2.
Exerccio 4.42 Escreva um mdulo HDL para o circuito do Exerccio 3.31.
Exerccio 4.45 Escreva um mdulo HDL para o circuito do Exerccio 4.34. O leitor poder utilizar o full
adder da Seo 4.2.5.
327
Exerccios de SystemVerilog
Os exerccios a seguir so especficos para SystemVerilog.
Exerccio 4.46 Qual o significado para um sinal declarado tri em SystemVerilog?
Exerccio 4.47 Reescreva o mdulo syncbad do Exemplo HDL 4.29. Utilize atribuies nonblocking,
mas faa mudanas no cdigo a fim de produzir um sincronizador correto com dois flip-flops.
Exerccio 4.48 Considere os dois mdulos SystemVerilog abaixo. Eles tm a mesma funo? Esboce
o hardware que cada um desenvolve.
module code1(input logic clk, a, b, c,
output logic y);
logic x;
always_ff @(posedge clk) begin
x <= a & b;
y <= x | c;
end
endmodule
module code2 (input logic a, b, c, clk,

output logic y);
logic x;
y <= x | c;
x <= a & b;
328
end
endmodule
Exerccio 4.49 Repita o Exerccio 4.48, substituindo <= por = em cada atribuio.
Exerccio 4.50 Os mdulos SystemVerilog abaixo mostram erros que os estudantes cometem em
laboratrio. Explique os erros em cada mdulo e mostre como consert-los.
(a) module bscula(input logic clk,
output reg [3:0] q);
always @(clk)
if (clk) q <= d;
endmodule
(b) module gates(input logic [3:0] a, b,

output logic [3:0] y1, y2, y3, y4, y5);
always @(a)
begin
y1 = a & b;
y2 = a | b;
y3 = a ^ b;
y4 = ~(a & b);
y5 = ~(a | b);
end
endmodule
(c) module mux2(input logic [3:0] d0, d1,

input logic s,
329

always @(posedge s)
if (s) y <= d1;
else y <= d0;
endmodule
(d) module twoflops(input logic clk,

input logic d0, d1,
output logic q0, q1);
q1 = d1;
q0 = d0;
endmodule
(e) module FSM(input logic clk,

input logic a,
output logic out1, out2);
logic state;
// next state logic and register (sequential)
always_ff @(posedge clk)
if (state == 0) begin
if (a) state <= 1;
end else begin
if (~a) state <= 0;
end
always_comb // output logic (combinational)
if (state == 0) out1 = 1;
else out2 = 1;
endmodule
330
(f) module priority(input logic [3:0] a,

always_comb
if (a[3]) y = 4'b1000;
else if (a[2]) y = 4'b0100;
else if (a[1]) y = 4'b0010;
else if (a[0]) y = 4'b0001;
endmodule
(g) module divideby3FSM(input logic clk,

input logic reset,
output logic out);
logic [1:0] state, nextstate;
// State Register
always_ff @(posedge clk, posedge reset)
if (reset) state <= S0;
else state <= nextstate;
// Next State Logic

always @(state)
case (state)
S0: nextstate = S1;
S1: nextstate = S2;
S2: nextstate = S0;
endcase
// Output Logic
331
assign out = (state == S2);

endmodule
(h) module mux2tri(input logic [3:0] d0, d1,

input logic s,
output tri [3:0] y);
tristate t0(d0, s, y);
tristate t1(d1, s, y);
endmodule
(i) module floprsen(input logic clk,

input logic reset,
input logic set,
output logic [3:0] q);
always_ff @(posedge clk, posedge reset)
if (reset) q <= 0;
else q <= d;
always @(set)
if (set) q <= 1;
endmodule
(j) module and3(input logic a, b, c,

output logic y);
logic tmp;
always @(a, b, c)
begin
tmp <= a & b;
y <= tmp & c;
332
end
endmodule
Exerccios de VHDL
Os exerccios seguintes so especficos para VHDL.
Exerccio 4.51 Em VHDL, por que necessrio escrever

q <= '1' when state = S0 else '0';
ao invs de simplesmente
q <= (state = S0);
Exerccio 4.52 Cada um dos mdulos VHDL abaixo contm um erro. Por brevidade, apenas a arquitetura
mostrada. Assuma que a clusula de uso library e a declarao entity esto corretas. Explique os
erros e mostre como consert-los.
(a) architecture synth of bscula is
begin
process(clk) begin
if clk = '1' then q <= d;
end if;
end process;
end;
(b) architecture proc of gates is

begin
process(a) begin
Y1 <= a and b;
333
y2 <= a or b;
y3 <= a xor b;
y4 <= a nand b;
y5 <= a nor b;
end process;
end;
(c) architecture synth of flop is

begin
process(clk)
q <= d;
end;
(d) architecture synth of priority is

begin
process(all) begin
if a(3) then y <= "1000";
elsif a(2) then y <= "0100";
elsif a(1) then y <= "0010";
elsif a(0) then y <= "0001";
end if;
end process;
end;
(e) architecture synth of divideby3FSM is

type statetype is (S0, S1, S2);
signal state, nextstate: statetype;
begin
if reset then state <= S0;
334

state <= nextstate;
end if;
end process;
process(state) begin
case state is
when S0 => nextstate <= S1;
end case;
end process
q <= '1' when state = S0 else '0';

end;
(f) architecture struct of mux2 is

component tristate
en: in STD_LOGIC;
end component;
begin
end;
(g) architecture asynchronous of floprs is

begin
335
if reset then
q <= '0';
q <= d;
end if;
end process;
process(set) begin
if set then
q <= '1';
end if;
end process;
end;
336
Os exerccios abaixo apresentam questes que tm sido perguntadas em entrevistas de empregos para
vagas em projetos digitais.
Pergunta 4.1 Escreva uma linha de cdigo HDL que obtenha um barramento de 32-bits chamado data,
com outro sinal chamado sel, para produzir um resultado result de 32-bits. Se sel TRUE,
result=data. De outro modo, result deve ser sempre 0.
Pergunta 4.2 Explique a diferena entre declaraes blocking e nonblocking em SystemVerilog. D

exemplos.
Pergunta 4.3 O que a seguinte declarao em SystemVerilog faz?

result = | (data[15:0] & 16'hC820);
337
338
5. Blocos de Construo Digital
5.1. INTRODUO
At este momento, examinmos o projeto de circuitos combinatrios e sequenciais utilizando
equaes Booleanas, esquemticos e HDL. Este Captulo apresenta blocos de construo
sequenciais e combinatrios mais elaborados utilizados em sistemas digitais. Esses blocos incluem
circuitos aritmticos, contadores, registradores de deslocamento, matrizes de memria e matrizes
lgicas. Esses blocos de construo no so teis apenas por direito prprio, mas tambm
demonstram os princpios da hierarquia, modularidade e regularidade. Os blocos de construo
so hierarquicamente montados a partir de componentes mais simples, tais como portas lgicas,
multiplexadores e decodificadores. Cada bloco de construo tem uma interface bem definida e
pode ser tratado como uma caixa preta quando a implementao subjacente no importante. A
estrutura regular de cada bloco de construo facilmente estendida para diferentes tamanhos.
No Captulo 7, usamos muitos desses blocos de construo para construir um microprocessador.
5.2. CIRCUITOS ARITMTICOS

Os circuitos aritmticos so os blocos de construo centrais dos computadores. Computadores
e lgica digital executam vrias funes aritmticas: adio, subtrao, comparaes,
deslocamentos, multiplicao e diviso. Esta Seo descreve as implementaes de hardware para
todas estas operaes.
339
Captulo cinco Blocos de Construo Digital
5.2.1. Adio
A adio uma das operaes mais comuns em sistemas digitais. Vamos primeiro considerar como
adicionar dois nmeros binrios de 1-bit. Ento, vamos estender a nmeros binrios de N-bits. Os
somadores tambm ilustram compromisso entre velocidade e complexidade.
Half Adder
Comeamos por construir um half adder de 1-bit. Como mostrado na Figura 5.1, o half adder tem
duas entradas, A e B, e duas sadas, S e Cout. S representa a soma de A e B. Se A e B so ambos 1, S
2, o que no pode ser representado com um nico dgito binrio. Em vez disso, indicado com um
transporte (carry) Cout na prxima coluna. Este somador parcial pode ser construdo a partir de uma
porta XOR e uma porta AND.
Figura 5.1 Half adder de 1-bit Num somador multi-bit, Cout adicionado ou transportado para o prximo bit mais significativo.
Por exemplo, na Figura 5.2, o bit de transporte mostrado em azul a sada Cout da primeira coluna da
adio de 1-bit e a entrada Cin para a segunda coluna de adio. No entanto, o half adder carece de
uma entrada Cin para aceitar o Cout da coluna anterior. O full adder, descrito na prxima seo, resolve
este problema.
Figura 5.2 Bit de transporte (carry)
Full Adder
O full adder, introduzido na Seo 2.1, aceita o transporte de entrada em Cin como mostrado na
Figura 5.3. A figura tambm mostra as equaes de sada para S e Cout.
Somador Carry Propagate
Um somador de N-bits soma duas entradas de N-bits, A e B, e um transporte de entrada Cin para
produzir um resultado S de N-bits e um transporte de sada Cout. normalmente designado de
somador carry propagate (CPA - carry propagate adder) porque o transporte de sada de um bit se
propaga para o prximo bit. O smbolo de um CPA mostrado na Figura 5.4; ele desenhado como
um somador completo exceto que A, B, e S so barramentos, em vez de bits nicos. Trs
Figura 5.3 Full adder de 1-bit
implementaes CPA comuns so chamadas de somadores ripple-carry, carry-lookahead, e prefix.
340
Somador Ripple-Carry
A maneira mais simples de construir um somador de N-bits com propagao do transporte Os esquemas tipicamente mostram sinais
encadear N full adders. O Cout de um estgio atua como o Cin do estgio seguinte, como mostrado que fluem da esquerda para a direita. Os
na Figura 5.5 para uma adio de 32-bits. Isso chamado de somador ripple carry. uma boa circuitos aritmticos quebram esta regra,
aplicao da modularidade e regularidade: o mdulo full adder reutilizado vrias vezes para pois o transporte flui da direita para a
formar um sistema maior. O somador ripple carry tem a desvantagem de ser muito lento quando esquerda (da coluna menos significativa
N elevado. S31 depende de C30, que depende de C29, que depende de C28, e assim por diante todo para a coluna mais significativa).
o caminho at Cin, como mostrado em azul na Figura 5.5. Dizemos que h um ripple do transporte
ao longo da cadeia de transporte. O atraso do circuito somador, tripple, aumenta diretamente com
o nmero de bits, conforme indicado na Equao 5.1, onde tFA o atraso de um full adder.
Figura 5.4 Somador carry propagate

Ao longo dos sculos, as pessoas tm
usado muitos dispositivos para realizar
aritmtica. As crianas contam pelos
dedos (e alguns adultos furtivamente
tambm o fazem). Os chineses e os
Figura 5.5 Somador ripple-carry de 32-bits babilnios inventaram o baco to cedo
quanto 2400 AC. As rguas de clculo,
= (5.1) inventadas em 1630, ainda eram usadas
at dcada de 1970, quando as
Somador Carry-Lookahead
calculadoras de mo cientficas se
A razo fundamental pela qual os somadores ripple-carry de dimenso elevada so lentos que tornaram predominantes. Os
os sinais de transporte devem-se propagar atravs de cada bit no somador. O somador carry computadores e as calculadoras digitais
so hoje omnipresentes. Qual ser o
lookahead (CLA carry lookahead adder) outro tipo de somador com transporte que resolve este
prximo mtodo?
341
problema dividindo o somador em blocos e fornecendo circuitos para determinar rapidamente o

transporte de sada de um bloco assim que o transporte de entrada conhecido. Assim, diz-se que
antecipa os blocos ao invs de esperar a propagao atravs de todos os full adders dentro de um
bloco. Por exemplo, um somador de 32-bits pode ser dividido em oito blocos de 4-bits.
O CLA usa sinais de gerar (G) e propagar (P) que descrevem como uma coluna ou bloco determina
o transporte de sada. A coluna i de um somador dito gerar um transporte se produz um transporte
de sada independente do transporte de entrada. A coluna i de um somador garante a gerao de um
transporte Ci se Ai e Bi so ambos 1. Assim Gi, o sinal gerar da coluna i, calculado como Gi = AiBi. A
coluna dita propagar um transporte se produz um transporte de sada sempre que h um transporte
de entrada. A coluna i ir propagar um transporte de entrada, Ci-1, se Ai ou Bi 1. Assim, Pi = Ai + Bi.
Com base nestas definies, podemos reescrever a lgica de transporte para uma determinada
coluna do somador. A coluna i de um somador ir gerar um transporte de sada Ci se gerar um
transporte, Gi, ou se propagar um transporte de entrada, PiCi-1. Na forma de equao,
= + ( + )1 = + 1 (5.2)
As definies de gerar e propagar estendem-se a blocos de mltiplos bits. Um bloco dito gerar
um transporte de sada se produz um transporte de sada independente do transporte de entrada no
bloco. O bloco dito propagar um transporte se produz um transporte de sada sempre que h um
transporte de entrada no bloco. Podemos definir Gij e Pij como sinais de gerar e propagar de blocos
abrangendo as colunas i at j.
Um bloco gera um transporte se a coluna mais significativa gera um transporte, ou se a coluna
mais significativa propaga um transporte e a coluna anterior gera um transporte, e assim por diante.
Por exemplo, a lgica de gerao para um bloco que se estende pelas colunas 3 at 0
3:0 = 3 + 3 (2 + 2 (1 + 1 0 ) (5.3)
Um bloco propaga um transporte se todas as colunas do bloco propagam o transporte. Por
exemplo, a lgica de propagao para um bloco que se estende pelas colunas de 3 at 0
342
3:0 = 3 2 1 0 (5.4)
Usando os sinais de gerar e propagar do bloco, podemos rapidamente calcular o transporte de sada
do bloco, Ci, usando o transporte no bloco, Cj.
= : + : (5.5)
A Figura 5.6 (a) mostra um somador de 32-bits carry-lookahead composto por oito blocos de 4-bits.
Cada bloco contm um somador ripple-carry de 4-bits e alguma lgica lookahead para determinar o
transporte de sada do bloco, dado o transporte de entrada, como mostrado na Figura 5.6 (b). As portas
AND e OR necessrias para determinar os sinais gerar e propagar dos bits individuais, Gi e Pi, de Ai e Bi
so deixadas de fora por questes de simplicidade. Mais uma vez, o somador carry-lookahead
demonstra modularidade e regularidade.
Todos os blocos do CLA determinam os sinais gerar e propagar dos bits individuais e do bloco em
simultneo. O caminho crtico comea com a computao de G0 e G3:0 no primeiro bloco do CLA. Cin,
em seguida, avana diretamente para Cout atravs das portas AND/OR em cada bloco at o ltimo. Para
um somador grande, isto muito mais rpido do que esperar que o transporta se propague atravs de
cada bit consecutivo do somador. Finalmente, o caminho crtico atravs do ltimo bloco contm um
pequeno somador ripple-carry. Assim, um somador de N-bits dividido em blocos de k-bits tem um
atraso

= + _ + ( 1) _ + , (5.6)
onde tpg o atraso das portas indivduo gerar/propagar (uma porta AND ou OR) para gerar Pi e Gi,
tpg_block o atraso para encontrar sinais de gerar/propagar Pi:j e Gi:j para um bloco de k-bits, e tAND-OR
o atraso de Cin at Cout atravs da lgica final AND/OR do bloco de k-bits do CLA. Para N > 16, o somador
carry-lookahead geralmente muito mais rpido do que o somador ripple-carry. No entanto, o atraso
do somador ainda aumenta linearmente com N.
343
Figura 5.6 (a) Somador de 32-bits carry-lookahead (CLA), (b) bloco CLA de 4-bits
Exemplo 5.1 ATRASO DO SOMADOR RIPPLE-CARRY E DO SOMADOR CARRY-LOOKAHEAD

Compare os atrasos de um somador ripple-carry de 32-bits e um somador carry-lookahead de 32-
bits com blocos de 4-bits. Suponha que o atraso de uma porta de duas entradas de 100 ps e que o
atraso do full adder de 300 ps.
Soluo: De acordo com a Equao 5.1, o atraso de propagao do somador ripple carry de 32
300 ps = 9,6 ns.
344
O CLA tem tpg = 100 ps, tpg_block = 6 100 ps = 600 ps, e tAND_OR = 2 100 ps = 200 ps. De acordo com
a Equao 5.6, o atraso de propagao do somador carry-lookahead de 32-bits com blocos de 4-bits , Os primeiros computadores usavam
somadores ripple carry, porque os
assim, 100 ps + 600 ps (32/4 - 1) x 200 ps + (4 300 ps) = 3,3 ns, quase trs vezes mais rpido do que o
componentes eram caros e os somadores
somador ripple-carry.
ripple-carry utilizavam menos hardware.
Somadores Prefix* Praticamente todos os PC modernos
usam somadores prefix em caminhos
Os somadores prefix estendem a lgica de gerar e propagar do somador carry lookahead para crticos, porque os transstores so agora
executar ainda mais rpido. Primeiro calculam G e P para pares de colunas, em seguida, para blocos de baratos e a velocidade de grande
4, em seguida, para os blocos de 8, em seguida, 16, e assim por diante at que o sinal de gerar para importncia.
cada coluna conhecido. As somas so calculadas a partir destes sinais.
Por outras palavras, a estratgia do somador prefix calcular o transporte
em Ci-1 para cada coluna i to rapidamente quanto possvel, em seguida, calcular a soma, utilizando
= ( ) 1 (5.7)
Define a coluna i = -1 para manter Cin, ento G-1 = Cin e P-1 = 0. Em seguida, Ci-1 = Gi-1:-1, porque haver
um transporte de sada da coluna i-1 se o bloco abrangendo i-1 a -1 gerar um transporte. O transporte
produzido pode ser gerado na coluna de i-1 ou gerada numa das colunas anteriores e propagado.
Assim, reescrevemos a Equao 5.7 como
= ( ) 1:1 (5.8)
Por isso, o principal desafio calcular rapidamente para todos os blocos os sinais gerar G-1:-1, G0:-1,
G1:-1, G2:-1,. . . , GN-2:-1. Estes sinais, juntamente com P-1:-1, P0:-1, P1:-1, P2:-1,. . . , PN-2:-1, so chamados
prefixos.
A Figura 5.7 mostra um somador prefix de N = 16-bits. O somador comea com uma pre-computao
para formar Pi e Gi para cada coluna de Ai e Bi usando portas AND e OR. Em seguida, usa log2N = 4 nveis
de clulas negras para formar os prefixos de Gi:j e Pi:j. Uma clula negra aceita as entradas da parte
superior de um bloco que abrange os bits i:k e da parte inferior abrangendo bits k-1:j. Combina estas
partes para formar sinais gerar e propagar para todo o bloco que abrange os bits i:j utilizando as
equaes
345
: = : + : 1: (5.9)
: = : 1: (5.10)
Por outras palavras, um bloco abrangendo os bits i:j ir gerar um transporte, se a parte superior
gerar um transporte ou se a parte superior propagar um transporte gerado na parte inferior. O bloco
ir propagar um transporte se ambas as partes, superior e inferior, propagarem o transporte.
Finalmente, o somador prefix calcula as somas usando a equao 5.8.
Em resumo, o somador prefix atinge um atraso que tem um crescimento logartmico em vez de
linear com o nmero de colunas do somador. Esta acelerao significativa, especialmente para
somadores com 32 ou mais bits, mas obtida custa de mais hardware do que um simples somador
de carry-lookahead. A rede de clulas negras chamada de prefix tree.
O princpio geral da utilizao de prefix trees para realizar computaes em que o tempo tem um
crescimento logartmico com o nmero de entradas uma tcnica poderosa. Com alguma habilidade,
ela pode ser aplicada a muitos outros tipos de circuitos (ver, por exemplo, o Exerccio 5.7).
O caminho crtico para um somador prefix de N-bits envolve a pre-computao de Pi e Gi seguido
por log2N estgios de clulas negras prefix para obter todos os prefixos. Gi-1:-1, prossegue ento
atravs da porta XOR final em baixo para calcular Si. Matematicamente, o atraso de um somador
prefix de N-bits
= + log 2 ( ) + , (5.11)
onde tpg-prefix o atraso de uma clula negra prefix.
346
Figura 5.7 Somador prefix de 16-bits
Exemplo 5.2 ATRASO DE UM SOMADOR PREFIX

Calcule o atraso de um somador prefix de 32-bits. Suponha que o atraso de cada porta de duas
entradas de 100 ps.
347
Soluo: O atraso de propagao de cada clula prefix negra tpg_prefix de 200 ps (ou seja, dois atrasos de
porta). Assim, usando a Equao 5.11, o atraso de propagao do circuito somador prefix de 32-bits de
100 ps + log2(32) 200 ps + 100 ps = 1,2 ns, que cerca de trs vezes mais rpido do que o somador
carry-lookahead e oito vezes mais rpido que o somador ripple-carry do Exemplo 5.1. Na prtica, os
benefcios no so assim to grandes, mas os somadores prefix ainda so substancialmente mais rpidos
do que as alternativas.
Colocando Tudo Junto

Esta Seo apresenta o half adder, full adder, e trs tipos de somadores por propagao do transporte:
ripple-carry, carry-lookahead, e somadores prefix. Os somadores mais rpidos exigem mais hardware e,
portanto, so mais caros e apresentam um consumo energtico maior. Estes compromissos devem ser
considerados ao escolher um somador apropriado para um projeto.
As linguagens de descrio de hardware fornecem a operao + para especificar um CPA. As
ferramentas de sntese modernas selecionam entre muitas implementaes possveis, escolhendo o
projeto mais barato (menor) que atende aos requisitos de velocidade. Isso simplifica muito o trabalho do
projetista. O Exemplo HDL 5.1 descreve um CPA com transportes de entrada e de sada.
Exemplo HDL 5.1 SOMADOR
SystemVerilog VHDL
module adder #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

(input logic [N1:0] a, b, use IEEE.NUMERIC_STD_UNSIGNED.ALL;
input logic cin,
output logic [N1:0] s, entity adder is
output logic cout); generic(N: integer := 8);
assign {cout, s} = a + b + cin; port(a, b: in STD_LOGIC_VECTOR(N1 downto 0);
endmodule cin: in STD_LOGIC;
s: out STD_LOGIC_VECTOR(N1 downto 0);
348
cout: out STD_LOGIC);

end;
architecture synth of adder is

signal result: STD_LOGIC_VECTOR(N downto 0);
begin
result <= ("0" & a) + ("0" & b) + cin;
s <= result(N1 downto 0);
cout
end;
Figura 5.8 Somador sintetizado
5.2.2. Subtraco
Lembre-se da Seo 1.4.6 em os que somadores podiam adicionar nmeros positivos e negativos
utilizando a representao numrica de complemento-2. A subtrao quase to fcil: inverter o
sinal do segundo nmero, em seguida adicionam-se. Inverter o sinal de um nmero em
complemento-2 realizado invertendo os bits e adicionando 1.
Para calcular Y = A - B, primeiro produza o complemento-2 de B: Inverta os bits de B para obter

Figura 5.9 Subtrator: (a) smbolo, (b)
e adicione 1 para obter -B = + 1. Adicione esta quantidade a A para obter Y = A + + 1 = A - B. Esta
implementao
soma pode ser realizada com um nico CPA atravs da adio de A + , com Cin = 1. A Figura 5.9
mostra o smbolo para um subtrator e o hardware para efetuar Y = A - B. O Exemplo HDL 5.2 descreve
um subtrator.
349
Exemplo HDL 5.2 SUBTRATOR
SystemVerilog VHDL
module subtractor #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

output logic [N1:0] y);
assign y = a b; entity subtractor is
endmodule generic(N: integer := 8);
port(a, b: in STD_LOGIC_VECTOR(N1 downto 0);
y: out STD_LOGIC_VECTOR(N1 downto 0));
end;
architecture synth of subtractor is

begin
y <= a b;
end;
Figura 5.10 Subtrator sintetizado
5.2.3. Comparadores
Um comparador determina se dois nmeros binrios so iguais ou se um maior ou menor do que
o outro. Um comparador recebe dois nmeros binrios A e B de N-bits. H dois tipos comuns de
comparadores.
350
Figura 5.11 Comparador de 4-bits igualdade: (a) smbolo, (b) implementao
Um comparador de igualdade produz uma sada que indica se A igual a B (A == B). Um comparador
de magnitude produz uma ou mais sadas, indicando os valores relativos de A e B.
O comparador de igualdade a pea mais simples de hardware. A Figura 5.12 mostra o smbolo e a
implementao de um comparador de igualdade de 4-bits. Primeiro verifica para determinar se os bits
correspondentes em cada coluna de A e B so iguais usando portas XNOR. Os nmeros so iguais se
todas as colunas forem iguais.
A comparao de magnitude geralmente feita atravs da computao de A - B e olhando para o
sinal (bit mais significativo) do resultado como mostrado na Figura 5.11. Se o resultado for negativo Figura 5.12 Comparador de
(isto , o bit de sinal um), ento A inferior a B. Caso contrrio A maior do que ou igual a B. magnitude de 4-bits
O Exemplo HDL 5.3 mostra como utilizar as vrias operaes de comparao.
Exemplo HDL 5.3 COMPARADORES
SystemVerilog VHDL
module comparator #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

input logic [N1:0] a, b,
output logic eq, neq, lt, lte, gt, gte); entity comparators is
generic(N: integer : = 8);
assign eq = (a == b); port(a, b: in STD_LOGIC_VECTOR(N1 downto 0);
assign neq = (a != b); eq, neq, lt, lte, gt, gte: out STD_LOGIC);
351
assign lt = (a < b); end;

assign lte = (a <= b);
assign gt = (a > b); architecture synth of comparator is
assign gte = (a >= b); begin
endmodule eq <= '1' when (a = b) else '0';
neq <= '1' when (a /= b) else '0';
lt <= '1' when (a < b) else '0';
lte <= '1' when (a <= b) else '0';
gt <= '1' when (a > b) else '0';
gte <= '1' when (a >= b) else '0';
end;
Figura 5.13 Comparadores sintetizado
352
5.2.4. ALU
Uma unidade aritmtica/lgica (ALU) combina uma variedade de operaes matemticas e lgicas
numa nica unidade. Por exemplo, uma ALU tpica pode realizar operaes de adio, subtrao,
comparao de magnitude, e operaes AND e OR. A ALU forma o corao da maioria dos sistemas de
computadores.
A Figura 5.14 mostra o smbolo para uma ALU de N-bits com entradas e sadas de N-bit. A ALU
recebe um sinal F de controle que especifica qual a funo a ser executada. Os sinais de controle iro
geralmente ser mostrados a azul para distingui-los dos sinais de dados. A Tabela 5.1 lista as funes
tpicas que a ALU pode executar. A funo SLT usada para a comparao de magnitude e ser
discutida mais adiante nesta seo.
Figura 5.14 Smbolo de uma ALU
Tabela 5.1 Operaes da ALU
A Figura 5.15 mostra uma implementao da ALU. A ALU contm um somador de N-bits e N portas
AND e OR de N entradas. Ela tambm possui inversores e um multiplexador para inverter a entrada B
quando o sinal de controlo F2 ativado. Um multiplexador 4:1 escolhe a funo desejada com base
nos sinais de controlo F1:0.
353
Mais especificamente, os blocos lgicos e aritmticos na ALU operam em A e BB. BB B ou ,

dependendo de F2. Se F1:0 = 00, o multiplexador de sada escolhe A AND BB. Se F1:0 = 01, a ALU
determina A OR BB. Se F1:0 = 10, a ALU executa adio ou subtrao. Note-se que F2 tambm o
transporte para o somador. Tambm devemos relembrar que + 1 = -B na aritmtica complemento-
2. Se F2 = 0, a ALU calcula A + B. Se F2 = 1, a ALU calcula A + + 1 = A - B.
Quando F2:0 = 111, a ALU executa a operao ativa se menor que (SLT - set if less than). Quando A
< B, Y = 1. Caso contrrio, o Y = 0. Por outras palavras, Y ativado a 1 se A for inferior a B.
A SLT realizada atravs do clculo de S = A - B. Se S negativo (isto , o bit de sinal est ativo), A
inferior a B. A unidade de extenso do zero (zero extend unit) produz uma sada de N-bits,
concatenando a sua entrada de 1-bit com zeros nos bits mais significativos. O bit de sinal (o bit N - 1)
de S a entrada para a unidade de extenso de zero.
Exemplo 5.3 ATIVA SE MENOR QUE

Configure uma ALU de 32-bits para a operao SLT. Suponha que A = 2510 e B = 3210. Mostre os
sinais de controlo e de sada, Y.
Soluo: Por causa de A < B, esperamos que Y seja 1. Para SLT, F2:0 = 111. Com F2 = 1, isto configura a
Figura 5.15 ALU de N-bits
unidade somador como um subtrator com uma sada S de 2510 - 3210 = -710 = 1111. . . 10012. Com F1:0
= 11, o multiplexador final estabelece Y = S31 = 1.
Algumas ALU produzem sadas extras, chamadas de flags, que fornecem informaes sobre a sada
da ALU. Por exemplo, uma flag de transbordo (overflow) indica que o resultado do somador
transbordou. Uma flag de zero indica que a sada da ALU 0.
O HDL para uma ALU de N-bits deixado para o Exerccio 5.9. Existem muitas variaes sobre esta
ALU bsica que suportam outras funes, tais como XOR ou a comparao de igualdade.
354
5.2.5. Shifters e Rotators

Os shifters e rotators deslocam os bits e multiplicam ou dividem por potncias de 2. Como o nome
indica, um shifter desloca um nmero binrio para a esquerda ou para a direita um nmero
especificado de posies. Existem vrios tipos de shifters normalmente utilizados:
O shifter lgico - desloca o nmero esquerda (LSL) ou direita (LSR) e preenche os lugares
vazios com 0.
Ex: 11001 LSR 2 = 00110; 11001 LSL 2 = 00100
O shifter aritmtico - o mesmo que um shifter lgico, mas nos deslocamentos para a direita
preenche os bits mais significativos, com uma cpia do bit mais significativo (msb). Isso til para
multiplicar e dividir nmeros com sinal (ver Sees 5.2.6 e 5.2.7). Nos deslocamentos aritmticos
para a esquerda (ASL) o mesmo que o shift lgico para a esquerda (LSV).
Ex: 11001 ASR 2 = 11110; 11001 ASL 2 = 00100
O rotator circula o nmero tal que os lugares vazios so preenchidos com os bits que saem da
outra extremidade.
Ex: 11001 ROR 2 = 01110; 11001 ROL 2 = 00111
Um shifter de N-bits pode ser construdo a partir de N multiplexadores N:1. A entrada deslocada
por 0 a N - 1 bits, dependendo do valor das log2N bits linhas de seleo. A Figura 5.16 apresenta o
smbolo e o hardware de shifter de 4-bits. Os operadores <<, >> e >>> normalmente indicam shift
esquerda, shift lgico direita e shift aritmtico direita, respectivamente. Dependendo do valor de
2-bits da quantidade de deslocamento shamt1:0, a sada Y recebe a entrada A deslocada por 0 a 3
bits. Para todos os shifter, quando shmt1:0 = 00, Y = A. O Exerccio 5.14 aborda o projeto de rotators.
Um shift esquerda um caso especial da multiplicao. Um shift esquerda de N bits multiplica
o nmero por 2N. Por exemplo, 0000112 << 4 = 1100002 equivalente a 310 x 24 = 4810.
355
Figura 5.16 Shifters de 4-bit: (a) shift esquerda, (b) shift lgico direita, (c) shift aritmtico
direita
Um shift aritmtico direita um caso especial de diviso. Um shift aritmtico direita por N bits
divide o nmero por 2N. Por exemplo, 111002 >>> 2 = 111112 equivalente a -410 / 22 = -110.
5.2.6. Multiplicao*
A multiplicao de nmeros binrios sem sinal semelhante multiplicao decimal, mas envolve
apenas 1 e 0. A Figura 5.17 compara a multiplicao em decimal e binrio. Em ambos os casos, os
produtos parciais so formados pela multiplicao de um nico dgito do multiplicador com todo o
multiplicando. Os produtos parciais so deslocados e somados para formar o resultado.
Em geral, um multiplicador N N multiplica dois nmeros de N-bits e produz um resultado de 2N
bits. Os produtos parciais da multiplicao binria so ou o multiplicando ou 0. A multiplicao de
356
nmeros binrios de 1-bit equivalente operao AND, de modo que portas AND so utilizadas para
formar os produtos parciais.
A Figura 5.18 mostra o smbolo, a funo e a implementao de um multiplicador 4 4. O
multiplicador recebe o multiplicando e o multiplicador, A e B, e produz o produto P. A Figura 5.18 (b)
mostra como os produtos parciais so formados. Cada produto parcial um nico bit do multiplicador
(B3, B2, B1, ou B0) AND os bits do multiplicando (A3, A2, A1, A0). Com operandos de N-bits, existem N
produtos parciais e N - 1 estgio somadores de 1-bit. Por exemplo, para um multiplicador 4 4, o
produto parcial da primeira linha B0 AND (A3, A2, A1, A0). Este produto parcial adicionado ao segundo
produto parcial deslocado, B1 e (A3, A2, A1, A0). As linhas subsequentes de portas AND e somadores
produzem e adicionam os produtos parciais restantes.
O HDL para um multiplicador fornecido no Exemplo HDL 5.4. Tal como acontece com os
somadores, muitos projetos diferentes de multiplicadores, com diferentes solues de compromisso
velocidade/custo existem. As ferramentas de sntese podem escolher o projeto mais adequado tendo
em conta as restries de tempo.
Figura 5.17 Multiplicao: (a) decimal, (b) binria
357
Figura 5.18 Multiplicador 4 4: (a) smbolo, (b) funo, (c) implementao
Exemplo HDL 5.4 MULTIPLICADOR
SystemVerilog VHDL
module multiplier #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

output logic [2*N1:0] y);
assign y = a * b; entity multiplier is
endmodule generic(N: integer := 8);
port(a, b: in STD_LOGIC_VECTOR(N1 downto 0);
y: out STD_LOGIC_VECTOR(2*N1 downto 0));
end;
architecture synth of multiplier is

begin
y <= a
end;
358
Figura 5.19 Multiplicador sintetizado
5.2.7. Diviso
A diviso binria pode ser realizada utilizando o seguinte algoritmo para nmeros sem sinal de N-
bits no intervalo [0, 2N-1]:
R = 0
for i = N1 to 0
R = {R << 1, Ai}
D = R B
if D < 0 then Qi = 0, R =R // R < B
else Qi = 1, R =D //R B
R = R
O resto parcial R inicializado a 0. O bit mais significativo do dividendo A torna-se ento o bit menos
significativo de R. O divisor B repetidamente subtrado deste resto parcial para determinar se se
encaixa. Se a diferena D negativa (isto , o bit de sinal de D 1), ento o bit quociente Qi 0 e a
diferena descartada. Caso contrrio, Qi 1, e o resto parcial atualizado para ser a diferena. Em
qualquer caso, o resto parcial , ento, dobrado (shift esquerda por uma coluna), o prximo bit mais
significativo de A torna-se o bit menos significativo de R, e o processo repete-se. O resultado satisfaz
= + .

A Figura 5.20 apresenta um esquema de uma matriz divisora de 4 bits. O divisor calcula A/B e
produz um quociente Q e um resto R. A legenda mostra o smbolo e o esquema para cada bloco na
matriz divisora. O sinal N indica se R - B negativo. Sendo obtido a partir da sada D do bloco mais
esquerda na fila, que o sinal da diferena.
O atraso de uma matriz divisora de N-bits aumenta proporcionalmente com N2 porque o transporte
deve-se propagar ao longo de todos os N estgios numa linha antes do sinal ser determinado e o
359
multiplexador selecionar R ou D. Isso se repete para todas as N linhas. A diviso uma operao
lenta e dispendiosa em hardware e, portanto, deve ser usada o menos frequentemente possvel.
Figura 5.20 Matriz divisora
5.2.8. Leituras Adicionais

A aritmtica computacional poderia ser objeto de um texto inteiro. Digital Arithmetic, de
Ercegovac e Lang, uma excelente viso geral desta temtica. CMOS VLSI Design, de Weste e Harris,
abrange o projeto de circuitos de alto desempenho para operaes aritmticas.
360
5.3. SISTEMAS NUMRICOS

Os computadores operam nmeros inteiros e fraces. At agora, s foi considerada a
representao de inteiros com e sem sinal, introduzida na Seo 1.4. Esta Seo apresenta os sistemas
numricos de vrgula fixa e de vrgula flutuante que podem representar nmeros racionais. Os nmeros
de vrgula fixa so anlogos aos decimais; alguns dos bits representam a parte inteira, e o resto
representa a fraco. Os nmeros de vrgula flutuante so anlogos notao cientfica, com uma
mantissa e um expoente.
5.3.1. Sistema Numrico de Vrgula Fixa
A notao de vrgula fixa possui uma vrgula binria implcita entre os bits do nmero inteiro e a
parte fraccionria, anlogo vrgula decimal entre os dgitos inteiros e fraccionrios de um nmero Figura 5.21 Notao de vrgula fixa
decimal ordinrio. Por exemplo, a Figura 5.21 (a) mostra um nmero de vrgula fixa com quatro bits de 6,75 com quatro bits inteiros e
quatro bits de fraccionrios
inteiros e quatro bits de fraccionrios. A Figura 5.21 (b) mostra a vrgula binria implcita em azul, e a
Figura 5.21 (c) mostra o valor decimal equivalente.
Os nmeros de vrgula fixa com sinal podem usar a notao de complemento-2 ou a notao
sinal/magnitude. A Figura 5.22 mostra a representao de vrgula fixa de -2,375 usando ambas as
notaes com quatro bits inteiros e quatro bits fraccionrios. A vrgula binria implcita mostrada em
azul para maior clareza. Na forma sinal/magnitude, o bit mais significativo usado para indicar o sinal.
A representao de complemento-2 formada invertendo os bits do valor absoluto e adicionando 1 ao Figura 5.22 Representao de vrgula
bit menos significativo. Neste caso, a posio do bit menos significativo na coluna 2-4. fixa de -2,375: (a) valor absoluto, (b)
sinal e magnitude, (c) complemento-
Como todas as representaes de nmeros binrios, os nmeros de vrgula fixa so apenas uma 2
coleo de bits. No h nenhuma maneira de saber da existncia da vrgula binria, exceto por acordo
das pessoas que interpretam o nmero.
Exemplo 5.4 ARITMTICA COM NMEROS DE VRGULA FIXA

Calcule 0,75 + -0,625 usando nmeros de vrgula fixa.
Soluo: Primeiro convertemos 0,625, a magnitude do segundo nmero, para a notao binria de
vrgula fixa. 0,625 2-1, por isso h um 1 na coluna 2-1, resultando 0,625-0,5 = 0,125. Porque 0,125 < 2-2,
361
h um 0 na coluna 2-2. Porque 0,125 2-3, existir um 1 na coluna 2-3, deixando 0,125-0,125 = 0.
Assim, deve existir um 0 na coluna 2-4. Colocando tudo isto junto, 0,62510 = 000,10102.
Os sistemas de nmeros de vrgula fixa
so comumente usados em aplicaes Usamos a representao de complemento-2 para nmeros com sinal para que a adio
bancrias e financeiras que necessitem de funcione corretamente. A Figura 5.23 mostra a converso de -0,625 para a notao de vrgula
preciso, mas no um grande intervalo de fixa de complemento-2.
representao.
A Figura 5.24 mostra a adio binria de vrgula fixa e o equivalente decimal para comparao.
Note-se que o primeiro 1 na adio de vrgula fixa da Figura 5.24 (a) ignorado a partir do
resultado de 8-bits.
Figura 5.23 Converso de vrgula fixa em complemento-2
Figura 5.24 Adio: (a) vrgula fixa binria, (b) equivalente decimal
5.3.2. Sistemas Numricos de Virgula Flutuante

Os nmeros de vrgula flutuante so anlogos notao cientfica. Eles contornam a limitao
de ter um nmero constante de bits inteiros e fraccionrios, permitindo a representao de
nmeros muito grandes ou muito pequenos. Tal como a notao cientfica, os nmeros de vrgula
flutuante tm um sinal, uma mantissa (M), uma base (B) e um expoente (E), como se mostra na
Figura 5.25. Por exemplo, o nmero 4.1 103 a notao cientfica do decimal 4100. Ele tem
uma mantissa de 4,1, uma base de 10, e um expoente 3. A vrgula decimal flutua para a posio
logo aps o dgito mais significativo. Os nmeros de vrgula flutuante tm base 2 com uma
362
mantissa binria. Os 32 bits so usados para representar um bit de sinal, 8 bits de expoente e 23 bits
mantissa.

Exemplo 5.5 NMEROS DE VRGULA FLUTUANTE DE 32-BITS
Figura 5.25 Nmero de vrgula
Apresente a representao de vrgula flutuante do nmero 228. flutuante
Soluo: Primeiro convertemos o nmero decimal para binrio: 22810 = 111001002 = 1,110012 27. A
Figura 5.26 apresenta a codificao de 32 bits, que ser mais tarde modificado para eficincia. O bit
de sinal positivo (0), os 8 bits de expoente tomam o valor 7, e os restantes 23-bits esto a mantissa.
Figura 5.26 Vrgula flutuante de 32-bits, verso 1
No sistema binrio de vrgula flutuante, o primeiro bit da mantissa ( esquerda da vrgula binria)
sempre igual a 1 e, portanto, no precisa ser armazenado. chamado de implicit leading one. A
Figura 5.27 mostra a representao de vrgula flutuante modificada de 228 10 = 111001002 20 =
1,110012 27. O implicit leading one no est includo na mantissa de 23-bits por motivos de
eficincia. Apenas os bits fraccionrios so armazenados. Isso liberta um bit extra para os dados teis.
Figura 5.27 Vrgula flutuante de 32-bits, verso 2
Figura 5.28 Notao vrgula flutuante IEEE 754
363
Fazemos uma modificao final no campo do expoente. O expoente deve representar valores
positivos e negativos. Para faz-lo, a vrgula flutuante utiliza um expoente biased, que o expoente
original mais um valor constante. A vrgula flutuante de 32-bits utiliza um valor constante de 127.
Por exemplo, para o expoente 7, o expoente biased 7 + 127 = 134 = 100001102. Para o expoente
-4, o expoente biased: -4 + 127 = 123 = 011110112. A Figura 5.28 mostra 1,110012 27 representado
na notao de vrgula flutuante com implicit leading one e expoente biased de 134 (7 + 127). Esta
notao obedece ao standard de vrgula flutuante IEEE 754.
Casos Especiais: 0, , NaN
Como pode ser aparente, h muitas O standard de vrgula flutuante IEEE tem casos especiais para representar nmeros, como zero,
maneiras razoveis para representar o infinito, e os resultados ilegais. Por exemplo, a representao do nmero zero problemtica em
nmeros de vrgula flutuante. Por muitos notao de vrgula flutuante, devido ao implicit leading one. Cdigos especiais com expoentes todos
anos, os fabricantes de computadores a 0 ou todos a 1 so reservados para estes casos especiais. A Tabela 5.2 mostra as representaes
usaram formatos incompatveis de de vrgula flutuante de 0, , e NaN. Tal como acontece com nmeros de sinal/ magnitude, a vrgula
vrgula flutuante. Os resultados de um flutuante tem representao positiva e negativa para o valor 0. O NaN utilizado para nmeros que
computador no podiam ser diretamente no existem, como 1 ou log2(-5).
interpretado por um outro computador. O
Institut of Electrical and Electronics Tabela 5.2 Notao IEEE 754 de vrgula flutuante para 0, , e NaN
Engineers resolveu este problema criando
o padro de vrgula flutuante IEEE 754 em
1985, que define os nmeros de vrgula
flutuante. Este formato de vrgula
flutuante agora utilizado quase
universalmente e discutido nesta seo.
Formatos de Preciso Simples e Dupla

At agora, examinamos nmeros de vrgula flutuante de 32-bits. Este formato tambm
chamado de preciso simples (single precision), single, ou float. O Standard IEEE 754 tambm define
364
os nmeros de dupla preciso de 64-bits (tambm chamados de doubles) que proporcionam maior
preciso e maior alcance. A Tabela 5.3 mostra o nmero de bits utilizados para os campos em cada
um dos formatos. A aritmtica de vrgula flutuante
geralmente realizada em hardware para
Excluindo os casos especiais mencionados anteriormente, os nmeros normais de preciso torna-la mais rpida. Este hardware,
simples abrangem uma gama de 1.175494 10-38 a 3,402824 1038. Eles tm uma preciso de chamado de unidade de vrgula flutuante
cerca de sete dgitos significativos decimais (porque 2-24 10-7). Da mesma forma, os nmeros (FPU - floating-point unit), tipicamente
normais de preciso dupla abrangem uma gama de 2,22507385850720 10-308 a distinto da unidade de processamento
1,79769313486232 10308 e tm uma preciso de cerca de 15 dgitos significativos decimais. central (CPU). O infame bug de diviso de
vrgula flutuante (FDIV) no Pentium FPU
Tabela 5.3 Formatos de preciso simples e dupla custou Intel $ 475 milhes para chamar
e substituir os chips defeituosos. O erro
ocorreu simplesmente porque uma tabela
de pesquisa no foi carregado
corretamente.
Arredondamento
Os resultados aritmticos que caem fora da preciso disponvel so arredondados para um
nmero vizinho. Os modos de arredondamento so: arredondar para baixo, arredondar para cima,
arredondar em direo a zero, e arredondar para o mais prximo. O modo de arredondamento
normal arredondar para o mais prximo. No modo de arredondamento para o prximo, se dois
nmeros esto igualmente perto, o que tiver um 0 na posio menos significativa da parte
fraccionria o escolhido.
Recorde-se que um nmero transborda (overflows) quando a sua magnitude demasiado grande
para ser representada. Da mesma forma, pode ocorrer um underflow quando o nmero demasiado
pequeno para ser representado. No modo de arredondamento para o mais prximo, os overflows
so arredondados at e os underflows so arredondados para baixo a 0.
365
Adio de Vrgula Flutuante

A adio de nmeros de vrgula flutuante no to simples como a adio de dois nmeros de
complemento-2. As etapas para adicionar os nmeros de vrgula flutuante com o mesmo sinal so
A vrgula flutuante no pode representar as seguintes:
alguns nmeros com exatido, como por
exemplo o 1,7. No entanto, quando o 1. Extrair os bits de expoente e fraccionrios.
leitor digita 1,7 na calculadora, vai ver
2. Acrescente o 1 para formar a mantissa.
exatamente 1,7, no 1,69999... . Para lidar
com isso, alguns aplicativos, como 3. Comparar os expoentes.
calculadoras e softwares financeiros,
usam o formato BCD (binary coded 4. Desloque a mantissa menor se for necessrio.
decimal) ou formatos com um expoente 5. Some as mantissas.
de base 10. Os nmeros BCD codificam
cada dgito decimal usando quatro bits 6. Normalize a mantissa e ajuste o expoente, se necessrio.
com um intervalo de 0 a 9. Por exemplo, a
notao BCD em vrgula fixa de 1,7 com 7. Arredonde o resultado.
quatro bits inteiros e quatro bits 8. Construa o expoente e o fraccionrio novamente num nmero de vrgula flutuante.
fraccionrios seria 0.001,0111. Claro,
nada gratuito. O custo seria o de uma A Figura 5.29 mostra a adio de vrgula flutuante de 7,875 (1,11111 22) com 0,1875 (1,1 2-
maior complexidade no hardware da 3). O resultado 8,0625 (1,0000001 23).
aritmtica e desperdcios na codificao

(codificaes A-F no seriam utilizadas), e, Aps a extrao dos bits de expoente e fraccionrios o implicit leading one includo nos passos
portanto, uma diminuio no 1 e 2, os expoentes so comparados subtraindo o expoente menor do expoente maior. O resultado
desempenho. Assim, para aplicaes de o nmero de bits, pelo qual, no passo 4, o menor nmero deslocado para a direita para alinhar
computao intensiva, a vrgula flutuante a vrgula binria implcita (isto , para tornar os expoentes iguais). Os nmeros alinhados so
muito mais rpida. adicionados. Uma vez que a soma tem uma mantissa que maior do que ou igual a 2,0, o resultado
normalizado, deslocando-o para a direita 1-bit e incrementando o expoente. Neste exemplo, o
resultado exato, assim, no necessrio fazer o arredondamento. O resultado armazenado na
notao de vrgula flutuante, removendo o implicit leading one da mantissa e acrescentando o bit
de sinal
366
Figura 5.29 Adio em vrgula flutuante
367
5.4. BLOCOS DE CONSTRUO SEQUENCIAIS No confunda registros de deslocamento

com os shifters da Seo 5.2.5.
Esta Seo examina blocos sequenciais, incluindo contadores e registros de deslocamento. registradores de deslocamento so blocos
lgicos sequenciais que deslocam um
5.4.1. Contadores novo bit de entrada em cada flanco do
Um contador binrio de N-bits, mostrado na Figura 5.30, um circuito aritmtico sequencial com relgio. Shifters so blocos lgicos
entradas de relgio e de reset e uma sada Q de N-bits. O reset repe a sada a 0. O contador avana combinacionais sem sinal de relgio que
ento ao longo de todas as 2N sadas possveis numa ordem binria, incremento no flanco ascendente deslocam uma entrada uma quantidade
do relgio. de vezes especificada.
A Figura 5.31 mostra um contador de N-bits composto por um somador e um registro resettable.
Em cada ciclo, o contador adiciona 1 ao valor armazenado no registrador. O Exemplo HDL 5.5 descreve
um contador binrio com reset assncrono.
Outros tipos de contadores, tais como contadores para cima/baixo, so explorados do Exerccio
5.43 at ao Exerccio 5.46.
5.4.2. Registradores de Deslocamento Figura 5.30 Smbolo do contador
Um registrador de deslocamento tem um relgio, uma entrada serie Sin, uma sada srie Sout e N
sadas paralelas QN-1:0, como mostrado na Figura 5.33. A cada borda ascendente do relgio, um novo
bit deslocado da entrada Sin e todo o contedo anterior deslocado para a frente. O ltimo bit no
registrador de deslocamento est disponvel em Sout. Os registros de deslocamento podem ser vistos
como conversores srie para paralelo. A entrada fornecida em srie (um bit de cada vez) no Sin.
Depois de N ciclos, as ltimas N entradas esto disponveis em paralelo em Q. Figura 5.31 Contador de N-bits
Um registrador de deslocamento pode ser construdo a partir de N flip-flops ligados em srie, como
mostrado na Figura 5.34. Alguns registradores de deslocamento tambm tm um sinal de reset para
inicializar todos os flip-flops.
Figura 5.32 Smbolo de um registro

de deslocamento
368
Exemplo HDL 5.5 CONTADOR
SystemVerilog VHDL
module counter #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

(input logic clk, use IEEE.NUMERIC_STD_UNSIGNED.ALL;
input logic reset,
output logic [N1:0] q); entity counter is
generic(N: integer := 8);
always_ff @(posedge clk, posedge reset) port(clk, reset: in STD_LOGIC;
if (reset) q <= 0; q: out STD_LOGIC_VECTOR(N-1 downto 0));
else q <= q + 1; end;
endmodule
architecture synth of counter is
begin
if reset then q <= (OTHERS => '0');
elsif rising_edge(clk) then q <= q + '1';
end if;
end process;
end;
Figura 5.33 Contador sintetizado
369
Um circuito relacionado o conversor de paralelo-para-srie que carrega N bits em paralelo e,

em seguida, desloca-os para fora, um de cada vez. Um registrador de deslocamento pode ser
modificado para realizar as duas operaes de srie-para-paralelo e de paralelo-para-srie,
adicionando uma entrada paralela DN-1:0, e um sinal de controlo de carga, conforme mostrado na
Figura 5.35. Quando a carga acivada, os flip-flops so carregados em paralelo a partir das entradas
D. Caso contrrio, o registrador de deslocamento opera normalmente. O Exemplo HDL 5.6 descreve
um tal registrador de deslocamento.
Scan Chains*
Os registradores de deslocamento so muitas vezes utilizados para testar circuitos sequenciais
usando uma tcnica chamada scan chains. O teste de circuitos combinatrios relativamente
simples. As entradas conhecidas chamadas de vectores de teste so aplicadas, e as sadas so
verificadas em relao ao resultado esperado. O teste de circuitos sequenciais mais difcil, porque
os circuitos tm estados. A partir de um estado inicial conhecido, pode ser necessrio um grande
nmero de ciclos de vectores de teste para colocar o circuito num estado desejado. Por exemplo,
para testar se o bit mais significativo de um contador de 32-bits avana de 0 para 1 requer a
reposio do contador, em seguida, a aplicao de 231 (cerca de dois bilhes) impulsos de relgio!
Figura 5.34 Esquema de um registrador de deslocamento
Figura 5.35 Registrador de deslocamento com carregamento paralelo

370
Exemplo HDL 5.6 REGISTRADOR DE DESLOCAMENTO COM CARREGAMENTO PARALELO
SystemVerilog VHDL
module shiftreg #(parameter N = 8) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

(input logic clk,
input logic reset, load, entity shiftreg is
input logic sin, generic(N: integer := 8);
input logic [N1:0] d, port(clk, reset: in STD_LOGIC;
output logic [N1:0] q, load, sin: in STD_LOGIC;
output logic sout); d: in STD_LOGIC_VECTOR(N1 downto 0);
q: out STD_LOGIC_VECTOR(N1 downto 0);
always_ff @(posedge clk, posedge reset) sout: out STD_LOGIC);
if (reset) q <= 0; end;
else if (load) q <= d;
else q <= {q[N2:0], sin}; architecture synth of shiftreg is
begin
assign sout = q[N1]; process(clk, reset) begin
endmodule if reset = '1' then q <= (OTHERS => '0');
if load then q <= d;
else q <= q(N2 downto 0) & sin;
end if;
end if;
end process;
sout <= q(N1);

end;
371
Figura 5.36 Registrador de deslocamento sintetizado
Para resolver este problema, os projetistas gostariam de ser capazes de observar e controlar
todos os estados da mquina diretamente. Isto feito pela adio de um modo de teste em que o
contedo de todos os flip-flops pode ser lido ou carregado com os valores desejados. A maioria dos
sistemas tem muitos flip-flops para que se possa dedicar pinos individuais para ler e escrever cada
flip-flop. Em vez disso, todos os flip-flops no sistema esto ligados entre si em um registrador de
deslocamento chamado de scan chain. Em operao normal, os flip-flops carregam dados da sua
entrada D e ignoram a scan chain. No modo de teste, os flip-flops deslocam em srie o seu contedo
para fora e deslocam novos contedos usando Sin and Shout. O multiplexador de carregamento
normalmente integrado no flip-flop para produzir um scannable flip-flop. A Figura 5.37 mostra o
esquema e o smbolo de um scannable flip-flop e ilustra como os flops em cascata permitem
construir um registro scannable de N-bit.
Figura 5.37 Scannable flip-flop: (a) esquemtico, (b) smbolo, e (c) scannable register de N-bits
372
Por exemplo, o contador de 32-bits pode ser testado dando entrada do padro 011111111 em
modo de teste, conta um ciclo de contagem em modo normal, em seguida, devolve o resultado, que
deve ser 100000000. Isto requer apenas 32 + 1 + 32 = 65 ciclos.
5.5. MATRIZES DE MEMRIA

As sees anteriores introduziram a aritmtica e os circuitos sequenciais para manipulao de
dados. Os sistemas digitais tambm necessitam de memrias para armazenar os dados utilizados e
gerados por esses circuitos. Os registros construdos a partir de flip-flops so uma espcie de
memria que armazena pequenas quantidades de dados. Esta Seo descreve matrizes de memria
que pode eficientemente armazenar grandes quantidades de dados.
A Seo comea com uma viso geral descrevendo as caractersticas compartilhadas por todas as
matrizes de memria. Em seguida, introduz trs tipos de matrizes de memria: memrias dinmicas
de acesso aleatrio (DRAM), memrias estticas de acesso aleatrio (SRAM), e memria s de leitura
Figura 5.38 Smbolo genrico de
(ROM). Cada memria difere na forma como armazena os dados. A Seo discute brevemente os
memria matricial
compromissos de rea e atraso e mostra como as matrizes de memria so usadas, no s para
armazenar dados, mas tambm para realizar funes lgicas. A Seo termina com o HDL de uma
matriz de memria.
5.5.1. Generalidades
A Figura 5.38 apresenta um smbolo genrico para uma matriz de memria. A memria est
organizada como uma matriz bidimensional de clulas de memria. A memria l ou escreve o
contedo de uma das linhas da matriz. Esta linha especificada por um endereo. O valor lido ou
escrito chamado de dado. Uma matriz com endereos de N-bits e dados de M-bits tem 2N linhas e
M colunas. Cada linha de dados chamado de word. Assim, a matriz contm 2N words de M-bits.
A Figura 5.39 apresenta uma matriz de memria com dois bits de endereo e trs bits de dados.
Os dois bits de endereo especificam uma das quatro linhas de dados (word) na matriz. Cada word
de dados possui trs bits de largura. A Figura 5.39 (b) mostra alguns dos possveis contedos da
Figura 5.39 Matriz de memria 4 x 3:
matriz de memria. (a) smbolo; (b) funo
373
A profundidade (depth) de uma matriz o nmero de linhas, e a largura (width) o nmero de

colunas, tambm chamado o tamanho da word. O tamanho de uma matriz dado como a
profundidade x largura. A Figura 5.39 uma matriz de 4-words x 3-bit, ou simplesmente uma matriz
4 3. O smbolo para uma matriz de 1024-palavra 32-bits mostrado na Figura 5.40. O tamanho
total deste conjunto de 32 kilobits (KB).
Clulas de Bit
Figura 5.40 Matriz de 32kB: depth = As matrizes de memria so construdas como uma matriz de clulas de bits, cada uma das quais
210 = 1024 words, width = 32 bits armazena 1-bit de dados. A Figura 5.41 mostra que cada clula de bit est ligada a uma wordline e
a uma bitline. Para cada combinao de bits de endereo, a memria acede a uma nica wordline
que ativa as clulas de bit nessa linha. Quando a wordline est a HIGH, os bits armazenados so
transferidos de ou para a bitline. Caso contrrio, a bitline est desligada da clula de bit. O circuito
para armazenar os bits varia com o tipo de memria.
Para ler uma clula de bit, a bitline inicialmente deixada flutuante (Z). Em seguida, a wordline
Figura 5.41 Clula de bit colocada a ON, permitindo que o valor armazenado conduza a bitline a 0 ou 1. Para escrever uma
clula de bit, a bitline colocada no valor desejado. Em seguida, a wordline colocada a ON, ligando
a bitline ao bit armazenado. O valor da bitline sobrepe-se ao contedo da clula de bit, escrevendo
o valor desejado no bit.
Organizao
A Figura 5.42 mostra a organizao interna de uma matriz de memria de 4 3. Naturalmente,
as memrias prticas so muito maiores, mas o comportamento de matrizes maiores pode ser
extrapolo a partir da matriz menor. Neste exemplo, a matriz armazena os dados a partir da Figura
5.39 (b).
374
Figura 5.42 Matriz de memria 4 x 3
Durante uma leitura de memria, uma wordline acedida, e a linha correspondente das clulas de
bit coloca as bitlines a HIGH ou LOW. Durante uma escrita na memria, as bitlines so primeiro
colocadas a HIGH ou LOW e depois uma wordline acedida, permitindo que os valores da bitline sejam
armazenados na mesma linha de clulas de bit. Por exemplo, para ler o endereo 10, as bitlines so
deixadas a flutuar, o decodificador acede a wordline2, e o dado armazenado nessa linha de clulas de
bit (100) lido para a Data bitlines. Para escrever o valor 001 no endereo 11, as bitlines so colocadas
no valor 001, em seguida, a wordline3 acedida e o novo valor (001) armazenado nas clulas de bit.
Portos de Memria
Figura 5.43 Memria de 3 portos
Todas as memrias tm um ou mais portos. Cada porto permite um acesso de leitura e/ou escrita a
um endereo de memria. Os exemplos anteriores consistiam em memrias de um porto nico.
As memrias multi-porto podem aceder a vrios endereos simultaneamente. A Figura 5.43 mostra
uma memria de trs portos com dois portos de leitura e um porto de escrita. A porta 1 l os dados do
375
endereo A1 para a sada de dados de leitura RD1. A porta 2 l os dados do endereo A2 para RD2. A
porta 3 escreve os dados a partir da entrada de dados WD3 no endereo A3 no flanco ascendente do
relgio se o write enable WE3 for ativado.
Tipos de Memrias
As matrizes de memria so especificadas pelo seu tamanho (depth x width) e nmero e tipo de
portos. Todas as matrizes de memria armazenam os dados como matrizes de clulas de bit, mas elas
diferem na forma como armazenam os bits.
As memrias so classificadas com base na forma como armazenam os bits na clula de bit. A
Robert Dennard, 1932. classificao mais ampla a memria de acesso aleatrio (RAM random access memory) versus
Inventou a DRAM em 1966 na IBM. memria apenas de leitura (ROM read only memory). A RAM voltil, o que significa que ela perde
Embora muitos estavam cpticos de que a os seus dados quando a energia desligada. A ROM no voltil, o que significa que ela mantm os
ideia iria funcionar, em meados da dcada seus dados indefinidamente, mesmo sem uma fonte de energia.
de 1970 as DRAM estavam praticamente
A RAM e a ROM receberam os seus nomes por razes histricas que no so j muito relevantes.
em todos os computadores. Ele alega ter
feito pouco trabalho criativo at que,
A RAM chamada de memria de acesso aleatrio porque todas as word de dados so acedidas com
chegado IBM, lhe entregaram um o mesmo atraso. Em contraste, uma memria de acesso sequencial, tal como um gravador de fita,
caderno de patentes e lhe disseram, acede a dados nas proximidades mais rapidamente do que a dados distantes (por exemplo, na outra
"coloque todas as suas ideias aqui extremidade da fita). A ROM chamada de memria apenas de leitura, porque, historicamente, s
dentro." Desde 1965, ele recebeu 35 podia ser lida, mas no escrita. Estes nomes so confusos, porque as ROM so tambm acedidas
patentes em semicondutores e aleatoriamente. Pior ainda, a maioria das ROM modernas podem ser no s lidas mas tambm
microelectrnica. (Foto cedida pela IBM.) escritas! A distino importante a lembrar que as RAM so volteis e as ROM so no volteis.
Os dois principais tipos de RAM so a RAM dinmica (DRAM) e RAM esttica (SRAM). As RAM
dinmicas armazenam dados como carga num capacitor, enquanto as RAM estticas usam um par de
inversores cross-coupled. H muitas variedades de ROM que mudam na forma como so escritas e
apagadas. Estes vrios tipos de memrias so discutidos nas sees seguintes.
5.5.2. Memria Dinmica de Acesso Aleatrio (DRAM)
Figura 5.44 Clula de bit DRAM A RAM dinmica (DRAM, pronuncia-se, d-ram) armazena um bit como a presena ou ausncia
de carga num capacitor. A Figura 5.44 apresenta uma clula de bit DRAM. O valor do bit armazenado
376
no capacitor. O transistor nMOS comporta-se como um interruptor que liga ou desliga o capacitor
da bitline. Quando a worldline acedida, o transistor nMOS liga-se e o valor do bit armazenado
transferido de ou para a bitline.
Como mostrado na Figura 5.45 (a), quando o capacitor carregado a VDD, o bit armazenado 1;
quando descarregado a GND (Figura 5.45 (b)), o bit armazenado 0. O n do capacitor dinmico,
porque no ativamente mantido HIGH ou LOW por um transistor amarrado a VDD ou a GND.
Figura 5.45 Armazenamento de valores em DRAM
Aps uma leitura, os valores dos dados so transferidos a partir do capacitor para a bitline. Aps
uma gravao, os valores dos dados so transferidos a partir da bitline para o capacitor. A leitura
destri o valor do bit armazenado no capacitor, de modo que a word de dados deve ser restaurada
(reescrita) depois de cada leitura. Mesmo quando a DRAM no lida, o contedo deve ser
refrescado (leitura e reescrita) a cada poucos milissegundos, porque a carga do capacitor Figura 5.46 Clula de bit SRAM
gradualmente sofre uma fuga.
5.5.3. Memria Esttica de Acesso Aleatrio (SRAM)
A RAM esttica (SRAM, pronuncia-se "es-ram") esttico porque os bits armazenados no
precisam ser atualizados. A Figura 5.46 apresenta uma clula de bits SRAM. O bit de dados
armazenado em inversores cross-coupled como os descritos na Seo 3.2. Cada clula tem duas
: Quando a linha de wordline acedida, ambos os transistores nMOS entram
sadas, bitline e
em conduo, e os valores dos dados so transferidos para ou a partir dos bitlines. Ao contrrio das
DRAM, se o rudo degradar o valor do bit armazenado, os inversores cross-coupled restauram o
valor.
377
5.5.4. rea e Atraso

Os flip-flops, as SRAM e as DRAM so todas memrias volteis, mas cada um tem diferentes
caractersticas de rea e atraso. A Tabela 5.4 mostra uma comparao destes trs tipos de memria
voltil. O bit de dados armazenado num flip-flop est disponvel imediatamente na sua sada. Mas os
flip-flops requerem pelo menos 20 transistores na sua construo. Geralmente, quanto mais
transistores um dispositivo tem, mais espao, consumo e custo ele requer. A latncia de uma DRAM
maior do que a de uma SRAM porque a bitline no acionada de forma ativa por um transstor. A
DRAM deve aguardar que a carga se mova lentamente (relativamente) do condensador para a bitline.
As DRAM tambm tm um rendimento fundamentalmente inferior s SRAM, porque ela deve atualizar
os dados periodicamente e depois de uma leitura. As tecnologias DRAM tais como a synchronous DRAM
(SDRAM) e double data rate SDRAM (DDR) tm sido desenvolvidas para ultrapassar este problema. A
SDRAM usa um relgio para fazer pipeline de acessos. As DDR SDRAM, s vezes chamadas
simplesmente de DDR, usam tanto a subida como a descida do relgio para aceder os dados,
duplicando assim a taxa de transferncia para uma dada velocidade de relgio. A DDR foi padronizada
pela primeira vez em 2000 e funcionava de 100 a 200 MHz. As normas posteriores, DDR2, DDR3 e
DDR4, aumentaram as velocidades de relgio, com velocidades em 2012 acima de 1 GHz.
A latncia da uma memria e a sua taxa de transferncia tambm dependem do tamanho da
memria; memrias maiores tendem a ser mais lentas do que as menores se todo o resto o mesmo.
O melhor tipo de memria para um projeto em particular depende das restries de velocidade, custo
e potncia.
Tabela 5.4 Comparao de memrias
378
5.5.5. Banco de Registradores

Os sistemas digitais costumam usar um nmero de registradores para armazenar variveis
temporrias. Este grupo de registradores, chamado de banco de registro, normalmente construdo
como uma matriz SRAM pequena, multi-porto, porque mais compacta do que um conjunto de flip-
flops.
A Figura 5.47 mostra um banco de registradores de 32 registros 32 bits com trs portos
construdo a partir de uma memria com trs portos semelhante ao da Figura 5.43. O banco de
registradores tem dois portos de leitura (A1/RD1 e A2/RD2) e uma porta de escrita (A3/WD3). Os
endereos de 5-bits, A1, A2 e A3, podem aceder a todos aos 25 = 32 registros. Ento, dois registradores
Figura 5.47 Banco de registros 32 x
podem ser lidos e um registro escrito simultaneamente.
32 com dois portos de leitura e um
5.5.6. Read Only Memory porto de escrita
As read only memory (ROM) armazenam um bit quanto na presena ou ausncia de um transstor.
A Figura 5.48 mostra uma simples clula de bit ROM. Para ler a clula, a bitline fracamente puxada
a HIGH. Em seguida, a wordline colocada a ON. Se o transstor est presente, ele puxa a bitline a
LOW. Se estiver ausente, a bitline permanece HIGH. Note-se que a clula de bit ROM um circuito
combinatrio e no tem estado a "esquecer" se a energia for retirada.
O contedo de uma ROM pode ser indicado usando a notao de ponto. A Figura 5.49 mostra a
notao de ponto para uma ROM de 4-words 3-bits contendo os dados da Figura 5.39. Um ponto na
interseo de uma linha (wordline) e uma coluna (bitline) indica que o bit de dados est a 1. Por
exemplo, a wordline superior tem um nico ponto em Dados1, de modo que a word de dados
armazenada no endereo 11 010.
Conceitualmente, as ROM podem ser construdas usando lgica de dois nveis com um grupo de
portas AND seguido por um grupo de portas OR. As portas AND produzem todos os mintermos Figura 5.48 Clulas de bit ROM
possveis e, portanto, formam um decodificador . A Figura 5.50 mostra a ROM da Figura 5.49 contendo 0 e 1
construda usando um decodificador e portas OR. Cada linha pontilhada na Figura 5.49 uma entrada
para uma porta OR na Figura 5.50. Para os bits de dados com um nico ponto, neste caso DATA0, no
necessria uma porta OR. Esta representao de uma ROM interessante porque mostra como a
379
ROM pode executar qualquer funo lgica de dois nveis. Na prtica, as ROM so construdas a partir
de transstores em vez de portas lgicas para reduzir o seu tamanho e custo. A Seo 5.6.3 explora
mais a implementao a nvel do transstor.
Fujio Masuoka, 1944-. Recebeu um Ph.D.

em engenharia eltrica pela Universidade
de Tohoku, no Japo. Desenvolveu
Figura 5.49 ROM 4 3: notao de ponto
memrias e circuitos de alta velocidade
para a Toshiba, de 1971 a 1994. Inventou O contedo da clula de bit ROM na Figura 5.48 especificado durante a fabricao pela presena
a memria flash como um projeto no ou ausncia de um transistor em cada clula de bits. A ROM programvel (PROM) coloca um
autorizado realizado ao longo das noites e
transistor em cada clula de bit, mas fornece uma maneira de ligar ou desligar o transistor terra.
fins-de-semana no final de 1970. A flash
recebeu este nome porque o processo de
apagar a memria lembra o flash de uma
cmara. A Toshiba foi lenta na
comercializao desta ideia; a Intel foi a
primeira a comercializar em 1988. O
mercado das flashs tem crescido em $ 25
bilhes US por ano. O Dr. Masuoka
juntou-se mais tarde Universidade de
Tohoku e est trabalhando para
desenvolver um transstor tridimensional.
Figura 5.50 ROM 4 3: implementao utilizando portas

380
Os dispositivos Universal Serial Bus (USB)

substituram as disquetes e os CD para
Figura 5.51 Clula de bit ROM programvel por fusvel compartilhamento de arquivos, porque os
custos de Flash caram de forma
A Figura 5.51 apresenta a clula de bit para uma ROM programvel por fusvel. O utilizador dramtica.
programa a ROM atravs da aplicao de uma tenso elevada para queimar seletivamente os fusveis.
Se o fusvel est presente, o transstor est ligado a GND e a clula contm um 0. Se o fusvel
destrudo, o transstor desligado da terra e a clula contm um 1. Isto tambm chamado de ROM
programvel uma s vez, porque o fusvel no pode ser reparado, uma vez que queimado.
As ROM reprogramveis fornecem um mecanismo reversvel para ligar ou desligar o transstor a
GND. As erasable PROM (EPROM) substituem o transstor nMOS por um floating-gate transistor. A
porta flutuante no est fisicamente ligada a qualquer outro condutor. Quando tenses elevadas
adequadas so aplicadas, os eltrons passam atravs de um isolador para a porta flutuante, fechando
o transstor e ligando a bitline wordline (sada do decodificador ). Quando a EPROM exposta
radiao ultravioleta (UV) intensa por cerca de meia hora, os eltrons so removidos da porta
flutuante, tornando o transstor aberto. Essas aes so chamadas de programao e apagar,
respectivamente. As PROM apagveis eletricamente (EEPROM) e as memria flash usam princpios
semelhantes, mas contm circuitos no chip para apagar, bem como a programao, assim nenhuma
luz UV necessria. As clulas de bit EEPROM so individualmente apagveis; a memria flash apaga
blocos maiores de bits e mais barata porque so necessrios menos circuitos de apagamento. Em
381
2012, a memria flash custava cerca de $ 1 US por GB, e o preo continua a cair em 30 a 40% ao ano.
A memria flash tornou-se uma maneira extremamente popular para armazenar grandes
As ROM programveis podem ser quantidades de dados em sistemas portteis alimentados por baterias, como cmeras e leitores de
programadas com um programador de
msica.
dispositivo como o mostrado abaixo. O
dispositivo programador est ligado a um Em resumo, as ROM modernas no so realmente apenas de leitura; elas podem ser programadas
computador, que determina o tipo de (escritas). A diferena entre a RAM e ROM que a ROM demora mais tempo para ser escrita, mas
ROM e quais os dados a programar. O so no-volteis.
dispositivo programador destri os
fusveis ou injeta carga numa porta 5.5.7. Lgica Usando Matrizes de Memria
flutuante na ROM. Assim, o processo de Embora elas sejam usadas principalmente no armazenamento de dados, as matrizes de memria
programao s vezes chamado tambm podem executar funes de lgica combinatria. Por exemplo, a sada da ROM Data2 na
queimar (burning) uma ROM. Figura 5.49 o XOR das duas entradas de endereos. Da mesma forma DATA0 a NAND das duas
entradas. A memria 2N-word M-bits pode executar qualquer funo combinatria de N entradas
e M sadas. Por exemplo, a ROM na Figura 5.49 executa trs funes de duas entradas.
Figura 5.52 Matriz de memria 4-word 1-bit usada como lookup table
382
As matrizes de memria usadas para executar lgica so chamadas de lookup tables (LUT). A
Figura 5.52 apresenta uma matriz de memria de 4-word 1 bit usada como uma lookup table para
executar a funo Y = AB. Usando a memria para executar a lgica, o utilizador pode procurar o
valor de sada para uma dada combinao de entrada (endereo). Cada endereo corresponde a
uma linha na tabela verdade, e cada bit de dados corresponde a um valor de sada.
5.5.8. Memria HDL
O Exemplo HDL 5.7 descreve uma RAM 2N-word M-bit. A RAM tem um enable de escrita
sncrono. Por outras palavras, a escrita ocorre no flanco ascendente do relgio se a permisso de
escrita acedida. A leitura ocorre de imediato. Quando a energia aplicada pela primeira vez, o
contedo da RAM imprevisvel.
O Exemplo HDL 5.8 descreve uma ROM 4-word 3-bit. O contedo da ROM especificado na
instruo case do HDL. Uma ROM to pequena como esta pode ser sintetizada com portas lgicas,
em vez de uma matriz. Note-se que o decodificador de sete segmentos do Exemplo HDL 4.24
sintetiza numa ROM na Figura 4.20.
Exemplo HDL 5.7 RAM
SystemVerilog VHDL
module ram #(parameter N = 6, M = 32) library IEEE; use IEEE.STD_LOGIC_1164.ALL;

(input logic clk, use IEEE.NUMERIC_STD_UNSIGNED.ALL;
input logic we,
input logic [N1:0] adr, entity ram_array is
input logic [M1:0] din, generic(N: integer := 6; M: integer := 32);
output logic [M1:0] dout); port(clk,
we: in STD_LOGIC;
logic [M1:0] mem [2**N1:0]; adr: in STD_LOGIC_VECTOR(N1 downto 0);
din: in STD_LOGIC_VECTOR(M1 downto 0);
always_ff @(posedge clk) dout: out STD_LOGIC_VECTOR(M1 downto 0));
if (we) mem [adr] <= din; end;
383
assign dout = mem[adr]; architecture synth of ram_array is

endmodule type mem_array is array ((2**N1) downto 0)
of STD_LOGIC_VECTOR (M1 downto 0);
signal mem: mem_array;
begin
process(clk) begin
if we then mem(TO_INTEGER(adr)) <= din;
end if;
end if;
end process;
dout <= mem(TO_INTEGER(adr));

end;
Figura 5.53 RAM sintetizada
384
Exemplo HDL 5.8 ROM
SystemVerilog VHDL
module rom(input logic [1:0] adr, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [2:0] dout):
entity rom is
always_comb port(adr: in STD_LOGIC_VECTOR(1 downto 0);
case(adr) dout: out STD_LOGIC_VECTOR(2 downto 0));
2'b00: dout <= 3'b011; end;
2'b01: dout <= 3'b110;
2'b10: dout <= 3'b100; architecture synth of rom is
2'b11: dout <= 3'b010; begin
endcase process(all) begin
endmodule case adr is
when "00" => dout <= "011";
when "01" => dout <= "110";
when "10" => dout <= "100";
when "11" => dout <= "010";
end case;
end process;
end;
385
5.6. MATRIZES LGICAS

Tal como as memrias, as portas lgicas podem ser organizadas em matrizes regulares. Se as ligaes
so realizadas de modo a poderem ser programadas, estas matrizes lgicas podem ser configuradas
para executar qualquer funo, sem que o utilizador tenha que efetuar ligaes especficas. A estrutura
regular simplifica o projeto. As matrizes lgicas so produzidas em massa em grandes quantidades, pelo
que so baratas. As ferramentas de software permitem que os utilizadores realizem o mapeamento de
projetos lgicos nessas matrizes. A maioria das matrizes lgicas tambm reconfigurvel, permitindo
que o projeto possa ser modificado sem necessidade de substituir o hardware. A configurabilidade
valiosa durante o processo de desenvolvimento e tambm til em campo, porque um sistema pode
ser atualizado, basta simplesmente carregar uma nova configurao.
Esta Seo apresenta dois tipos de matrizes lgicas: programmable logic arrays (PLA) e field
programmable gate arrays (FPGA). As PLA, a tecnologia mais antiga, executam apenas funes lgicas
combinatrias. As FPGA podem executar tanto lgica combinatria e como sequencial.
5.6.1. Programmable Logic Arrays
As programmable logic arrays (PLA) implementam dois nveis lgicos de combinaes na forma de
soma de produtos (SOP). As PLA so construdas a partir de uma matriz AND seguida por uma matriz
OR, como se mostra na Figura 5.54. As entradas (na forma verdadeira e complementar) do entrada na
matriz AND, que produz implicantes, que por sua vez passam pelas portas OR em conjunto para formar
as sadas. Uma PLA M N P-bits tem M entradas, N implicantes e P sadas.
Figura 5.54 PLA M N P-bit
386
A Figura 5.55 mostra a notao de ponto para uma PLA 3 3 2-bits que desempenha as funes =
+ e = . Cada linha na matriz forma um implicante. Os pontos em cada linha da matriz
indicam que literais compreendem o implicante. A matriz AND na Figura 5.55 forma trs implicantes:
, , e . Os pontos na matriz OR indicam que implicantes fazem parte da funo de sada.
A Figura 5.56 mostra como as PLA podem ser construdas usando dois nveis lgicos. Uma
implementao alternativa dada na Seo 5.6.3.
As ROM podem ser vistas como um caso especial de PLA. Uma ROM de 2M-words N-bits
simplesmente uma PLA M 2M N-bit. O decodificador comporta-se como um plano AND que produz
todos os 2M mintermos. A matriz ROM comporta-se como um plano OR que produz as sadas. Se a funo
no depende de todos os 2M mintermos, provvel que uma PLA seja menor do que uma ROM. Por
exemplo, uma ROM de 2-word 8-bits necessria para executar as mesmas funes realizadas pela PLA
3 3 2-bits mostrada nas Figura 5.55 e Figura 5.56.
Figura 5.55 PLA 3 3 2-bit: notao de ponto
387
As Simple programmable logic devices (PLD) so PLA melhoradas a que foram acrescentados
registros e vrios outros recursos aos planos de base AND e OR. No entanto, as PLD e as PLA tm sido
largamente deslocadas pelas FPGAs, que so mais flexveis e eficientes na construo de sistemas de
grande porte.
Figura 5.56 PLA 3 3 2-bits utilizando lgica de dois nveis

5.6.2. Field Programmable Gate Array
Uma field programmable gate array (FPGA) uma matriz de portas reconfigurveis. Usando
ferramentas de programao de software, o utilizador pode implementar projetos na FPGA usando
uma HDL ou um esquema. As FPGA so mais poderosas e mais flexvel do que as PLA por vrias razes.
Elas podem implementar tanto lgica combinatria como lgica sequencial. Elas tambm podem
implementar funes lgicas multi-nvel, enquanto as PLA s podem implementar lgica de dois
nveis. As FPGA modernas integram outros recursos teis, como multiplicadores internos, I/O de alta
velocidade, conversores de dados incluindo conversores analgico-digitais, matrizes grandes de RAM
e processadores.
388
As FPGA so os crebros de muitos

produtos de consumo, incluindo
automveis, equipamentos mdicos e
dispositivos de mdia como MP3
players. A srie Mercedes Benz Class-S,
Figura 5.57 Layout genrico de uma FPGA
por exemplo, tem mais de uma dzia
de Xilinx FPGA ou PLD para usos que As FPGA so construdas como uma matriz de elementos lgicos configurveis (LE logic elements),
vo desde do entretenimento, tambm conhecidos como configurable logic blocks (CLB). Cada LE pode ser configurado para
passando pela navegao, at aos
desempenhar funes combinatrias ou sequenciais. A Figura 5.57 apresenta um diagrama de blocos
sistemas de cruise control. As FPGA
geral de uma FPGA. Os LE esto rodeados por elementos de entrada/sada (IOE input output elements)
permitem mais facilmente um tempo
de mercado rpido e fazer a depurao
para a interface com o mundo exterior. Os IOE ligam as entradas e as sadas dos LE aos pinos de
ou adicionar recursos no final do empacotamento de chip. OS LE podem-se ligar-se a outros LE e IOE atravs de canais de
processo de projeto. encaminhamento programveis.
Dois dos principais fabricantes de FPGA so a Altera Corp. e a Xilinx, Inc. a Figura 5.58 mostra uma
nica LE da FPGA da Altera Cyclone IV introduzida em 2009. Os elementos-chave do LE so uma lookup
table de 4 entradas (LUT) e um registro de 1-bit. O LE tambm contm multiplexadores configurveis
para encaminhar os sinais atravs do LE. A FPGA configurada especificando o contedo das lookup
tables e seleo dos sinais para os multiplexadores.
389
O Cyclone IV LE tem uma LUT de 4 entradas e um flip-flop. Ao carregar os valores apropriados na

lookup table, a LUT pode ser configurada para executar qualquer funo de at quatro variveis. A
configurao da FPGA tambm envolve a escolha dos sinais de seleo que determinam como os
multiplexadores roteiam os dados atravs do LE e quais os LE e IOE vizinhos. Por exemplo, dependendo
da configurao do multiplexador, a LUT pode receber uma das suas entradas a partir de dados 3 ou da
sada do prprio registro do LE. As outras trs entradas sempre vm de dados 1, dados 2 e dados 4. As
entradas de dados 1-4 vm das IOE ou das sadas de outros LE, dependendo de encaminhamento
externo para o LE. A sada da LUT ou vai diretamente para a sada LE para funes combinatrias, ou
pode ser alimentada atravs do flip-flop para funes de registros. A entrada do flip-flop vem da sua
prpria sada LUT, entrada de dados 3, ou da sada do registro LE anterior. O hardware adicional inclui
suporte para a adio usando o hardware de carry chain, outros multiplexadores para roteamento, e
flip-flop enable e reset habilitar e redefinir. A Altera agrupa 16 LE para criar um logic array block (LAB)
e fornece ligaes locais entre os LE com o LAB.
390
Figura 5.58 Elemento lgico (LE) do Cyclone IV (Reproduzido com permisso da Altera Cyclone IV
Handbook 2010 Altera Corporation.)
Exemplo 5.6 CONSTRUO DE FUNES UTILIZANDO LE

Explique como configurar uma ou mais LE da Cyclone IV para executar as seguintes funes: (a) =
+ e = (b) = ; (c) um contador de diviso por 3 com codificao de estado
binrio (ver Figura 3.29 (a)). O leitor deve mostrar a interligao entre os LE conforme necessrio.
Soluo: (a) configurar dois LE. Uma LUT determina X e a outra LUT determina Y, como mostrado na
Figura 5.59. Para o primeiro LE, as entradas data 1, data 2, e data 3 so A, B, e C, respectivamente (estas
ligaes esto definidas atravs dos canais de encaminhamento). O data 4 um dont care, mas deve
estar vinculado a alguma coisa, por isso est vinculado a 0. Para o segundo LE, as entradas data 1 e data
2 so A e B; as outras entradas da LUT so dont cares e esto vinculadas a 0. Configura-se os
391
multiplexadores finais para selecionar as sadas combinatrias das LUT para produzir X e Y. Em geral,
um nico LE pode calcular qualquer funo de at quatro variveis de entrada deste modo.
(b) Configure a LUT do primeiro LE para calcular X = JKLM e a LUT do segundo LE para calcular Y =
XPQR. Configure os multiplexadores finais para selecionar as sadas combinatrias X e Y de cada LE. Esta
configurao mostrada na Figura 5.60. Os canais de encaminhamento entre os LE, indicadas pelas
linhas tracejadas a azul, ligam a sada do LE 1 entrada do LE 2. Em geral, um grupo de LE pode calcular
desta forma funes com N variveis de entrada.
(c) A FSM tem dois bits de estado (S1: 0) e uma sada (Y). O prximo estado depende dos dois bits do
estado atual. Usar dois LE para calcular o prximo estado a partir do estado atual, como mostrado na
Figura 5.61. Dois flip-flops, um de cada LE, so usados para manter este estado. Os flip-flops tm uma
entrada de reset, que pode ser ligada a um sinal externo de reset. Os registros de sada so
realimentados para as entradas das LTU usando o multiplexador do data 3 e os canais de
encaminhamento entre LE, como indicado pelas linhas tracejadas a azul. Em geral, um outro LE pode
ser necessrio para calcular a sada Y. No entanto, neste caso Y = S0, por isso Y pode vir do LE 1. Assim,
toda a FSM fica contida em dois LE. Em geral, uma FSM requer pelo menos um LE para cada bit de
estado, e pode exigir LE adicionais para a sada ou lgica do prximo estado, se so demasiado
complexos para caber numa nica LUT
392
Figura 5.59 Configurao do LE para duas funes de at quatro entradas cada
Figura 5.60 Configurao do LE para uma funo de mais de quatro entradas
393
Figura 5.61 Configurao do LE para uma FSM com dois bits de estado
Em resumo, o LE do Cyclone IV pode executar uma funo combinatria e/ou registrada que pode
envolver at quatro variveis. Outros fabricantes de FPGA usam uma organizao um pouco diferente,
mas os mesmos princpios gerais se aplicam. Por exemplo, a Xilinx FPGAs 7-series usa LUT de 6 entradas
em vez de LUT de 4 entradas.
O projetista configura uma FPGA primeiro criando uma descrio esquemtica ou HDL do projeto. O
desenho ento sintetizado na FPGA. A ferramenta de sntese determina como as LUT, os
multiplexadores e os canais de encaminhamento devem ser configurados para desempenhar as funes
especificadas. Essa informao de configurao ento transferida para a FPGA. Dado que a FPGA
Cyclone IV armazena a sua informao de configurao na SRAM, elas so facilmente reprogramadas.
A FPGA pode carregar o contedo da sua SRAM de um computador no laboratrio ou a partir de um
chip EEPROM quando o sistema arranca. Alguns fabricantes incluem uma EEPROM diretamente na FPGA
ou usam fusveis de programao nica para configurar a FPGA.
Exemplo 5.7 ATRASO DO LE

Alyssa P. Hacker est a construir uma mquina de estado finito que deve executar a 200 MHz. Ela
usa uma FPGA Cyclone IV GX com as seguintes especificaes: tLE = 381 ps per LE tsetup = 76 ps, e tpcq =
199 ps para todos os flip-flops. O atraso de conduo entre LE de 246 ps. Suponha que o hold time
para os flip-flops 0. Qual o nmero mximo de LE que o seu projeto pode usar?
394
Soluo: Alyssa utiliza a Equao 3.13 para determinar o atraso de propagao mximo da lgica: tpd Tc
- ( tpcq + tsetup).
Assim, o tpd = 5 ns - (0,199 ns + 0,076 ns), logo tpd 4,725 ns. O atraso de cada LE mais o atraso de
conduo entre LE, tLE+wire, de 381 ps + 246 ps = 627 ps. O nmero mximo de LE, N, NtLE+wire 4.725
ns. Assim, N = 7.
5.6.3. Implementao de Matrizes*

Para minimizar o seu tamanho e custo, as ROM e as PLA usam normalmente pseudo-nMOS ou circuitos
dinmicos (ver Seo 1.7.8), em alternativa s portas lgicas convencionais.
A Figura 5.62 (a) mostra a notao de ponto para uma ROM 4 3-bits que executa as seguintes
funes: = , = + , e = . Estas so as mesmas funes que as da Figura 5.49,
com as entradas de endereo renomeado A e B e as sadas de dados renomeadas para X, Y, e Z. A
implementao pseudo-MOS dada na Figura 5.62 (b). Cada sada do decodificador est ligada s portas
dos transstores nMOS da sua linha. O leitor deve-se lembrar que nos circuitos pseudo-nMOS, os weak
transstores pMOS puxam a sada a HIGH somente se no h caminho para GND atravs do pull-down
(nMOS) network.
Transstores pull-down so colocados em cada juno, sem um ponto. Os pontos do diagrama de
notao de ponto da Figura 5.62 (a) ficam visveis na Figura 5.62 (b) para facilitar a comparao. Os weak
transstores pull-up puxam a sada a HIGH para cada wordline sem um transstor de pull-down. Por
exemplo, quando AB = 11 a 11 wordline est a HIGH e transstores em X e Z fecham e puxam essas sadas
a LOW. A sada Y no tem transstor ligando com o 11 wordline, ento Y puxado a HIGH pelos weak pull-
up.
As PLA tambm podem ser construdas usando circuitos pseudo-nMOS, como mostrado na Figura 5.63
para o PLA a partir da Figura 5.55. Os transstores pull-down (nMOS) so colocados no complemento de
pontos literais na matriz AND e nas linhas pontilhadas da matriz OR. As colunas na matriz OR so enviadas
atravs de um inversor, antes de serem alimentadas para as sadas dos bits. Mais uma vez, os pontos
azuis do diagrama de notao de ponto da Figura 5.55 so deixados visveis na Figura 5.63 para facilitar
a comparao.
395
Figura 5.62 Implementao da ROM: (a) notao de ponto, (b) circuito pseudo-nMOS
Figura 5.63 PLA 3 3 2-bits utilizando circuito pseudo-nMOS
396
5.7. SUMRIO
Este Captulo introduziu os blocos de construo digital utilizados em muitos sistemas digitais. Esses
blocos incluem circuitos aritmticos, como somadores, subtratores, comparadores, shifters,
multiplicadores e divisores; circuitos sequenciais, como contadores e registros de deslocamento; e
matrizes de memria e lgica. O Captulo tambm explorou as representaes de vrgula fixa e de vrgula
flutuante de nmeros fraccionrios. No Captulo 7 usamos esses blocos de construo para construir um
microprocessador.
Os somadores formam a base da maioria dos circuitos aritmticos. Um half adder adiciona duas
entradas de 1-bit, A e B, e produz uma soma e um transporte de sada. Um full adder estende o half adder
e aceita um transporte de entrada. Uma cascata de N full adders podem ser interligados para formar um
carry propagate adder (CPA) que adiciona dois nmeros de N-bits. Este tipo de CPA chamado de ripple-
carry adder porque o transporte se propaga atravs de cada um dos full adders. CPA mais rpidos podem
ser construdos utilizando tcnicas de lookahead ou prefix.
Um subtrator nega a segunda entrada e adiciona-a ao primeiro. Um comparador de magnitude subtrai
um nmero de outro e determina o valor relativo com base no sinal do resultado. Um multiplicador
constitui produtos parciais usando portas AND, em seguida, adiciona esses bits usando full adders. Um
divisor subtrai repetidamente o divisor do restante parcial e verifica o sinal da diferena para determinar
os bits do quociente. Um contador usa um somador e um registro para incrementar a contagem em
execuo.
Os nmeros fraccionrios so representados utilizando formas de vrgula fixa ou vrgula flutuante. Os
nmeros de vrgula fixa so anlogos aos decimais, e os nmeros de pontos flutuante so anlogos
notao cientfica. Os nmeros de vrgula fixa usam circuitos aritmticos comuns, enquanto os nmeros
de vrgula flutuante requerem hardware mais elaborado para extrair e processar o sinal, expoente e
mantissa.
As grandes memrias so organizadas em conjuntos de words. As memrias tm um ou mais portos de
leitura e/ou escrita s palavras. As memrias volteis, como as SRAM e as DRAM, perdem o seu contedo
quando a energia desligada. A SRAM mais rpida do que a DRAM, mas exige mais transstores. Um
397
banco de registro uma pequena matriz SRAM multi-porto. As memrias no volteis, chamadas
ROM, mantm seu estado indefinidamente. Apesar dos nomes, a maioria das ROM modernas pode
ser escrita.
As matrizes so tambm uma forma comum de construir lgica. As matrizes de memria podem
ser usadas como lookup tables para realizar funes combinatrias. As PLA so compostas de ligaes
dedicadas entre matrizes configurveis de AND e OR; elas s implementam lgica combinatria. As
FPGA so compostas de muitas pequenas lookup tables e registros; elas implementam lgica
combinatria e sequencial. O contedo da lookup table e as suas interligaes pode ser configurado
para executar uma qualquer funo lgica. As FPGA modernas so fceis de reprogramar e so grandes
e baratas o suficiente para construir sistemas digitais altamente sofisticados, por isso, elas so
amplamente utilizadas em produtos comerciais de mdio e baixo volume assim como na educao.
398
Exerccios
Exerccio 5.1 Qual o atraso para os seguintes tipos de somadores de 64-bits? Suponha que cada porta
de duas entradas tem um atraso de 150 ps e que um atraso do full adder de 450 ps.
(a) Um somador ripple-carry
(b) Um somador carry-lookahead com blocos de 4-bits
(c) Um somador prefix
Exerccio 5.2 Projete dois somadores: um somador ripple-carry de 64-bits e um somador carry
lookahead de 64-bits com blocos de 4-bits. Use apenas portas de duas entradas. Cada porta de duas
entradas tem 15 m2, tem um atraso de 50 ps, e tem 20 fF de capacidade total da porta. O leitor pode
assumir que a energia esttica insignificante.
(a) Compare a rea, o atraso, e a potncia dos somadores (operando em 100 MHz e 1,2 V).
(b) Discuta o compromisso entre a potncia, a rea e o atraso
Exerccio 5.3 Explique porque um projetista pode optar por usar um somador ripple-carry em
alternativa a um somador carry-lookahead.
Exerccio 5.4 Projete o somador prefix de 16-bits da Figura 5.7 em HDL. Simule e teste o seu mdulo
para provar que ele funciona corretamente.
Exerccio 5.5 A rede prefix mostrada na Figura 5.7 utiliza clulas negras para determinar todos os prefix.
Alguns do bloco de propagao dos sinais no so realmente necessrios. Projete uma "clula cinzenta"
399
que receba os sinais G e P para bits i:k e k-1: j, mas produza apenas Gi:j, e no Pi:j. Redesenhe a rede
prefix, substituindo clulas negras por clulas cinzentas sempre que possvel.
Exerccio 5.6 A rede prefix mostrada na Figura 5.7 no a nica maneira para calcular todos os prefixs
num tempo logartmico. A rede Kogge-Stone outra rede prefix comum que executa a mesma funo
usando diferentes ligaes das clulas pretas. Faa uma pesquisa relativa aos somadores Kogge-Stone e
desenhe um esquema semelhante ao da Figura 5.7 que mostra a ligao de clulas negras num somador
Kogge-Stone.
Exerccio 5.7 Lembre-se que um codificador de prioridade de N-entradas tem log2N sadas que
codifica qual das N entradas recebe prioridade (ver Exerccio 2.36).
(a) Projete um codificador de prioridade de N-entradas que tenha um atraso que aumenta
algoritmicamente com N. Esboce o seu projeto e fornea o atraso do circuito em termos de atraso de (a)
seus elementos do circuito.
(b) Codifique o seu projeto em HDL. Simule e teste o seu mdulo para provar que ele funciona
corretamente.
Exerccio 5.8 Projete os seguintes comparadores para nmeros de 32-bits. Esboce os esquemas.
(a) igual a
(b) maior que
(c) inferior ou igual a
400
Exerccio 5.9 Projete a ALU de 32-bits mostrado na Figura 5.15 usando a sua HDL favorita. O leitor pode
fazer o mdulo de nvel superior, comportamental ou estrutural.
Exerccio 5.10 Adicione uma sada de overflow ALU de 32-bits do Exerccio 5.9. A sada verdadeira
quando o resultado do somador transborda. Caso contrrio, ela FALSE.
(a) Escreva uma equao Booleana para a sada de overflow.
(b) Desenhe o circuito de overflow.
(c) Criar a ALU modificada em HDL.
Exerccio 5.11 Adicione uma sada de Zero ALU de 32-bits do Exerccio 5.9. A sada TRUE quando
Y == 0.
Exerccio 5.12 Escreva um testbench para testar a ALU de 32-bits do Exerccio 5.9, Exerccio 5.10, ou
Exerccio 5.11. Em seguida, deve us-lo para testar a ALU. Incluir se necessrio test vector files. Certifique-
se de testar casos suficientes para convencer um cptico razovel de que as funes da ALU funcionam
corretamente.
Exerccio 5.13 Projete um deslocador que sempre desloca por 2-bits uma entrada de 32-bits. A entrada
e a sada so ambas de 32-bits. Explique o projeto por palavras suas e esboce um esquema. Implemente o
seu projeto na sua HDL favorita.
Exerccio 5.14 Projete rotators de 4-bits para a esquerda e para a direita. Esboce um esquema do seu
projeto. Implemente o seu projeto na sua HDL favorita.
401
Exerccio 5.15 Projete um shifter de 8-bits para a esquerda usando apenas 24 multiplexadores 2:1. O deslocador aceita uma entrada A de 8
bits e um valor de deslocamento de trs bits, shamt2:0. Uma sada Y de 8 bits produzida. Esboce o esquema.
Exerccio 5.16 Explique como construir qualquer deslocador de N-bits ou rotator usando apenas log2 N multiplexadores 2:1.
Exerccio 5.17 O funnel shifter mostrado na Figura 5.64 pode executar qualquer deslocamento de N-bits ou operao de rotao. Uma entrada
de 2N-bits deslocada de k bits. A sada Y so os N bits menos significativos do resultado. Os N bits mais significativos de entrada so chamados
de B e os N bits menos significativos so chamados de C. Ao escolher valores apropriados de B, C e K, o shifter funil pode executar qualquer tipo
de deslocamento ou rotao. Explique o que esses valores devem ser em termos de A, shamt, e N para:
(a) Shift lgico de A para a direita por shamt
(b) Shift aritmtico de A para a direita por shamt
(c) Shift de A para a esquerda por shamt
(d) Rotate de A para a direita por shamt
(e) Rotate de A para esquerda por shamt
402
Figura 5.64 Funnel shifter
Exerccio 5.18 Encontre o caminho crtico para o multiplicador 4 4 da Figura 5.18 em termos de atraso
da porta AND (TAND) e um atraso do somador (TFA) Qual o atraso de um multiplicador N N construdo
da mesma maneira?
Exerccio 5.19 Encontre o caminho crtico para o divisor 4 x 4 da Figura 5.20 em termos do atraso de
um multiplexar 2:1 (tMUX), de atraso de um somador (TFA), e de atraso de um inversor (TINV). Qual o atraso
de um divisor de N N construda da mesma maneira?
Exerccio 5.20 Projete um multiplicador que opere com dois nmeros em complemento-2.
Exerccio 5.21 Uma unidade de extenso de sinal estende um nmero em complemento-2 de M para
N bits (N > H), copiando o bit mais significativo da entrada para os bits mais significativos da sada (ver
Seo 1.4.6). Recebe uma entrada A de M-bits e produz uma sada Y de N-bits. Esboce um circuito para
uma unidade de extenso de sinal com uma entrada de 4-bits e uma sada de 8-bits. Escreva o cdigo HDL
do seu projeto.
403
Exerccio 5.22 Uma unidade de extenso de zero estende um nmero sem sinal de M para N bits (N
> M), colocando zeros nos bits mais significativos da sada. Esboce um circuito para uma unidade de
extenso zero, com uma entrada de 4-bits e uma sada de 8-bits. Escreva o HDL para seu projeto.
Exerccio 5.23 Determine 111001.0002 / 001100.0002 em binrio usando o algoritmo de diviso

padro da escola primria. Mostre seu trabalho.
Exerccio 5.24 Qual o intervalo de nmeros que podem ser representados pelos seguintes sistemas
numricos?
(a) nmeros sem sinal de 24-bits de vrgula fixa com 12-bits inteiros e 12-bits fraccionrios
(b) nmeros de sinal e magnitude de 24-bits de vrgula fixa com 12-bits inteiros e 12-bits fraccionrios
(c) nmeros em complemento-2 de 24-bits de vrgula fixa com 12-bits inteiros e 12-bits fraccionrios
Exerccio 5.25 Expresse os seguintes nmeros de base decimal no formato de sinal/magnitude de

16-bits usando vrgula fixa de 8-bits inteiros e 8-bits fraccionrios. Expresse a sua resposta em
hexadecimal.
(a) -13,5625
(b) 42,3125
(c) -17,15625
404
Exerccio 5.26 Expresse os seguintes nmeros de base decimal no formato de sinal/magnitude de 12-
bits usando vrgula fixa de 6-bits inteiros e 6-bits fraccionrios. Expresse a sua resposta em hexadecimal.
(a) -30,5
(b), 16,25
(c) -8,078125
Exerccio 5.27 Expresse os nmeros de base decimal do Exerccio 5.25 no formato complemento-2 de
16-bits com vrgula fixa com 8-bits inteiros e 8-bits fraccionrios. Expresse a sua resposta em
hexadecimal.
Exerccio 5.28 Expresse os nmeros de base decimal do Exerccio 5.26 no formato complemento-2 de
12-bits com vrgula fixa com 6-bits inteiros e 8-bits fraccionrios. Expresse a sua resposta em
hexadecimal.
Exerccio 5.29 Expresse os nmeros de base decimal do Exerccio 5.25 no formato de vrgula flutuante
IEEE 754 de preciso simples. Expresse a sua resposta em hexadecimal.
Exerccio 5.30 Expresse os nmeros de base decimal do Exerccio 5.26 no formato de vrgula flutuante
IEEE 754 de preciso simples. Expresse a sua resposta em hexadecimal.
Exerccio 5.31 Converta os seguintes nmeros binrios de complemento-2 de vrgula fixa para a base
decimal. A vrgula binria implcita mostrada explicitamente para ajudar na sua interpretao.
(a) 0101,1000
405
(b) 1111,1111
(c) 1000,0000
Exerccio 5.32 Repita o Exerccio 5.31 para os seguintes nmeros binrios em complemento-2 de
ponto.
(a) 011101,10101
(b) 100110,11010
(c) 101000,00100
Exerccio 5.33 Ao adicionar dois nmeros de vrgula flutuante, o nmero com o expoente menor
deslocado. Qual a necessidade? Explique por palavras suas e fornea um exemplo para justificar a sua
explicao.
Exerccio 5.34 Adicione os seguintes nmeros de vrgula flutuante IEEE 754 de preciso simples.
(a) C0123456 + 81C564B7
(b) D0B10301 + D1B43203
(c) 5EF10324 + 5E039020
Exerccio 5.35 Adicione os seguintes nmeros de vrgula flutuante IEEE 754 de preciso simples.
(a) C0D20004 + 72407020
(b) C0D20004 + 40DC0004
406
(c) (5FBE4000 + 3FF80000) + DFDE4000

(Porque que o resultado no intuitivo? Explique.)
Exerccio 5.36 Expanda os passos seguido na Seo 5.3.2 para fazer com que a adio em vrgula
flutuante funcione para nmeros negativos e positivos de vrgula flutuante.
Exerccio 5.37 Considere os nmeros de vrgula flutuante IEEE 754 de preciso simples.
(a) Quantos nmeros podem ser representados pelo formato IEEE 754 de preciso simples de vrgula
flutuante? O leitor no precisa contar ou NaN.
(b) Quantos nmeros adicionais poderiam ser representados se e NaN no estavam
representados?
(c) Explique porque a e a NaN so dadas representaes especiais.
Exerccio 5.38 Considere os seguintes nmeros decimais: 245 e 0,0625.

(a) Escreva os dois nmeros, utilizando a notao de vrgula flutuante de preciso simples. D suas
respostas em hexadecimal.
(b) Realize uma comparao de magnitude dos dois nmeros de 32-bits da parte (a). Por outras
palavras, interprete os dois nmeros de 32-bits como nmeros de complemento-2 e compare-os. Ser
que a comparao de inteiros fornece um resultado correto?
(c) Voc decide avanar com uma nova notao de vrgula flutuante de preciso simples. Tudo
idntico ao definido pela norma de vrgula flutuante IEEE 754 de preciso simples, exceto que o leitor
representa o expoente usando complemento-2 em vez de usar uma bias. Escreva os dois nmeros
utilizando a nova norma. D as suas respostas em hexadecimal.
407
(e) Ser que a comparao inteira trabalha com a sua nova notao de vrgula flutuante estabelecida
em (d)?
(f) Porque conveniente na comparao de inteiros trabalhar com nmeros de vrgula flutuante?
Exerccio 5.39 Projete um somador de preciso simples de vrgula flutuante usando o seu HDL
favorito. Antes de codificar o projeto em HDL, esboce um esquema do seu projeto. Simule e teste o seu
somador para provar a um cptico que ele funciona corretamente. O leitor pode considerar apenas os
nmeros positivos e utilize a aproximao para zero (truncagem). Tambm pode ignorar os casos
especiais indicados na Tabela 5.2.
Exerccio 5.40 Neste problema, o leitor ir explorar o desenho de um multiplicador de 32-bits de

vrgula flutuante. O multiplicador tem duas entradas de vrgula flutuante de 32-bits e produz uma sada
de vrgula flutuante de 32-bits. O leitor pode considerar apenas os nmeros positivos e utilize a
aproximao para zero (truncagem). Tambm pode ignorar os casos especiais indicados na Tabela 5.2.
(a) Escreva os passos necessrios para executar a multiplicao de 32-bits de vrgula flutuante.
(b) Esboce o esquema de um multiplicador de 32-bits de vrgula flutuante.
(c) Projete um multiplicador de 32 bits de vrgula flutuante em HDL. Simule e teste o seu
multiplicador para provar a um cptico que ele funciona corretamente.
Exerccio 5.41 Neste problema, o leitor ir explorar o desenho de um somador prefix de 32-bits.
(a) Desenhe um esquema de seu projeto.
(b) Projete o somador prefix de 32-bits em HDL. Simule e teste o seu somador para provar que ele
funciona corretamente.
408
(c) Qual o atraso do seu somador prefix de 32-bits? Suponha que cada porta de duas entradas tem
um atraso de 100 ps.
(d) Projete uma verso do somador prefix de 32-bits com pipeline. Esboce o esquema de seu projeto.
Quo rpido o seu somador prefix com pipeline executa? O leitor pode assumir uma sobrecarga de
sequenciamento (tpcq + tsetup) de 80 ps. Faa o projeto de modo a funcionar to rapidamente quanto
possvel.
(e) Projete o somador prefix de 32-bits com pipeline em HDL.
Exerccio 5.42 Um incrementador adiciona 1 a um nmero de N-bit. Construa um incrementador de

8-bits usando um full adder.
Exerccio 5.43 Construa um contador sncrono up/down de 32-bit. As entradas so Reset e Up.
Quando Reset for 1, as sadas so todas 0. Caso contrrio, quando Up = 1, o circuito faz contagem
progressiva, e quando Up = 0, o circuito faz contagem regressiva.
Exerccio 5.44 Projete um contador de 32-bits que adiciona 4 a cada flanco do relgio. O contador
tem entradas de reset e de clock. Aps a reinicializao, a sada do contador colocada a 0.
Exerccio 5.45 Modifique o contador do Exerccio 5.44 tal que o contador seja incremento por quatro
ou carregue um novo valor de 32-bits, D, a cada flanco do relgio, dependendo de um sinal de controlo
load. Quando a load = 1, o contador carrega o novo valor D.
409
Exerccio 5.46 Um contador Johnson de N-bits consiste num registro de deslocamento de N-bits com
um sinal de reset. A sada do registro de deslocamento (Sout) invertido e alimentado de volta para a
entrada (Sin). Quando o contador reiniciado, todos os bits so colocados a 0.
(a) Mostre a sequncia de sadas, Q3:0, produzido por um contador Johnson de 4-bits comeando
imediatamente aps o contador tenha sido reinicializado
(b) Quantos ciclos devem decorrer para que um contador Johnson de N-bits repita uma sequncia?
Explique.
(c) Projete um contador decimal usando um contador Johnson de 5-bit, dez portas AND, e inversores.
O contador decimal tem um clock, um reset, e nove sadas Y9:0. Quando o contador reiniciado, Y0
ativado. Em cada ciclo subsequente, a prxima sada deve ser ativada. Depois de dez ciclos, o contador
deve repetir. Esboce um esquema do contador decimal.
(d) Quais as vantagens de um contador Johnson relativamente a um contador convencional?
Exerccio 5.47 Escreva o HDL para um scannable flip-flop de 4-bits como o mostrado na Figura 5.37.
Simule e teste o seu mdulo HDL para provar que ele funciona corretamente.
Exerccio 5.48 O idioma Ingls tem uma boa dose de redundncia que nos permite reconstruir
transmisses ilegveis. Os dados binrios tambm podem ser transmitidos de forma redundante para
permitir a correo de erros. Por exemplo, o nmero 0 poderia ser codificado como 00000 e o nmero
1 poderia ser codificado como 11111. O valor poderia, ento, ser enviado atravs de um canal ruidoso
que pode comutar dois dos bits. O receptor pode reconstruir os dados originais porque um 0 ter pelo
menos trs dos cinco bits recebidos como 0; semelhante a 1 ter pelo menos trs 1s.
(a) Proponha uma codificao para enviar 00, 01, 10 ou 11 codificados usando cinco bits de
informao de tal forma que todos os erros que corrompem um bit dos dados codificados podem ser
corrigidos. Dica: As codificaes 00000 e 11111 para 00 e 11, respectivamente, no vo funcionar.
410
(b) projete um circuito que recebe os dados de cinco bits codificados e os descodifique para 00, 01,
10, ou 11, mesmo se um bit dos dados transmitidos tenha sido alterado.
(c) Suponha que voc queria mudar para uma codificao alternativa de 5-bits. Como voc pode
implementar seu projeto para ser mais fcil alterar a codificao sem ter que usar um hardware
diferente?
Exerccio 5.49 A memria Flash EEPROM, simplesmente chamada de memria flash, uma inveno
relativamente recente que revolucionou a electrnica de consumo. Investigue e explique como funciona
a memria flash. Use um diagrama que ilustre a porta flutuante. Descrever como um bit na memria
programado. Cite corretamente as suas fontes.
Exerccio 5.50 A equipe de projeto de vida extraterrestre acaba de descobrir extraterrestes que vivem
no fundo do lago Mono. Eles precisam construir um circuito para classificar os extraterrestres pelo
potencial planeta de origem com base em caractersticas medidas disponveis da sonda da NASA:
esverdeamento, acastanhamento, viscosidade e feiura. A consulta cuidadosa de exobilogo conduz s
seguintes concluses:
Se o extraterrestre verde e viscoso ou feio, castanho e viscoso, ele poderia ser de Marte.
Se a criatura feia, castanha e viscosa, ou verde e no feia nem viscosa, ela poderia ser de Vnus.
Se a besta castanha e no feia nem viscosa ou verde e viscosa, ela poderia ser de Jpiter.
Note que esta uma cincia inexata; por exemplo, uma forma de vida que manchada de verde e
castanho e viscosa, mas no feia pode ser de Marte ou Jpiter.
(a) Programe uma PLA 4 4 3 para identificar o extraterrestre. O leitor pode usar a notao de
ponto.
(b) Programe uma ROM 16 3 para identificar o extraterrestre. O leitor pode usar a notao de ponto.
411
(c) Implemente o seu projeto em HDL.
Exerccio 5.51 Implemente as seguintes funes usando uma nica ROM 16 3. Use a notao de
ponto para indicar o contedo da ROM.
(a) = + +
(b) = +
(c) = + + +
Exerccio 5.52 implemente as funes do Exerccio 5.51 usando uma PLA 4 8 3. Voc pode usar a
notao de ponto.
Exerccio 5.53 Especifique o tamanho de uma ROM que o leitor poderia usar para programar cada
um dos seguintes circuitos combinatrios. Usar uma ROM para implementar estas funes uma boa
escolha de projeto? Explique porque sim ou porque no.
(a) um somador/subtrator de 16-bits com Cin e Cout
(b) um multiplicador 8 8
(c) um codificador de prioridade de 16-bits (ver Exerccio 2.36)
Exerccio 5.54 Considere os circuitos ROM da Figura 5.65. Para cada linha, pode o circuito na coluna
I ser substitudo por um circuito equivalente na coluna II pela programao adequada da ROM deste
ltimo?
412
Figura 5.65 Circuitos ROM
Exerccio 5.55 Quantos LE da FPGA Cyclone IV so necessrios para realizar cada uma das seguintes
funes? Mostrar como configurar um ou mais LE para executar a funo. O leitor deve ser capaz de fazer
isso por inspeo, sem a realizao de sntese lgica.
(a) a funo combinacional de Exerccio 2.13 (c)
(b) a funo combinacional de Exerccio 2.17(c)
(c) a funo de duas sadas do Exerccio 2.24
(d) a funo do Exerccio 2.35
(e) um codificador de prioridade com quatro-entradas (ver Exerccio 2.36)
413
Exerccio 5.56 Repita o Exerccio 5.56 para as seguintes funes.

(a) um codificador de prioridade de oito-entradas (ver Exerccio 2.36)
(b) um decodificador 3:8
(c) um somador de 4-bits carry propagate (sem transporte para dentro ou para fora)
(d) a FSM do Exerccio 3.22.
(e) o contador de cdigo de Gray do Exerccio 2.37
Exerccio 5.57 Considere o LE do Cyclone IV mostrado na Figura 2.58. De acordo com a folha de
dados, tem as especificaes de tempo indicados na Tabela 5.5.
(a) Qual o nmero mnimo de LE do Cyclone IV necessrios para implementar a FSM da Figura
3.26?
(b) Sem skew do relgio, qual a frequncia mxima de relgio a que esta FSM ser executada de
forma confivel?
(c) Com 3 ns de skew do relgio, qual a frequncia mxima de relgio a que esta FSM ser
executada de forma confivel?
414
Tabela 5.5 Cyclone IV temporizao
Exerccio 5.58 Repita o Exerccio 5.57 para a FSM da Figura 3.31 (b).
Exerccio 5.59 O leitor gostaria de usar uma FPGA para implementar um classificador de M&M com um
sensor de cor e motores para colocar os doces vermelhos num frasco e os doces verdes noutro. O projeto
deve ser implementado como uma FSM usando uma FPGA Cyclone IV. De acordo com a folha de dados, a
FPGA tem as caractersticas de timing indicadas na Tabela 5.5. Voc gostaria que a sua FSM fosse
executada a 100 MHz. Qual o nmero mximo de LE no caminho crtico? Qual a velocidade mais rpida
a que a FSM pode ser executada?
415
Os exerccios seguintes apresentam perguntas que foram feitas em entrevistas para empregos em
projeto digital.
Pergunta 5.1 Qual o maior resultado possvel se multiplicar dois nmeros de N-bits sem sinal?
Pergunta 5.2 A representao em Binary Coded Decimal (BCD) usa quatro bits para codificar cada
dgito decimal. Por exemplo, 4210 representado como 01000010BCD Explique por palavras suas porque
os processadores devem usar a representao BCD.
Pergunta 5.3 Projete hardware para adicionar dois nmeros de 8-bits sem sinal em BCD (ver pergunta
5.2). Esboce um esquema para o seu projeto, e escreva um mdulo em HDL para o somador BCD. As
entradas so A, B, e Cin, e as sadas so S e Cout. Cin e Cout so o transporte de 1-bit e A, B, e S so nmeros
BCD de 8-bits.
416
6. Arquitetura
6.1. INTRODUO
Os Captulos anteriores introduziram os conceitos de projeto digital e dos blocos de construo
digital. Neste Captulo, subiremos alguns nveis de abstrao para definir a arquitetura de um
computador. A arquitetura a viso que o programador tem do computador. Ela definida pelo
conjunto de instrues (linguagem) e localizaes dos operandos (registradores e memria).
Existem muitas arquiteturas diferentes, tais como x86, MIPS, SPARC, e PowerPC.
O primeiro passo no entendimento de qualquer arquitetura de computador aprender a sua
linguagem. As palavras numa linguagem de computador so chamadas instrues. O vocabulrio do
computador chamado conjunto de instrues. Todos os programas que rodam num computador
utilizam um mesmo conjunto de instrues. Mesmo aplicaes complexas de software, como o
processamento de palavras e aplicativos de planilhas, so eventualmente compilados numa srie de
instrues simples como adio, subtrao e saltos. Instrues computacionais indicam tanto a
operao a ser realizada quanto o operando a ser utilizado. Os operandos podem vir da memria,
de registradores, ou da instruo em si.
O hardware do computador entende apenas 0 e 1, logo, as instrues so codificadas como
nmeros binrios chamados linguagem de mquina. Do mesmo modo que ns utilizamos letras para
codificar a linguagem humana, os computadores utilizam nmeros binrios para codificar a
linguagem de mquina. Microprocessadores so sistemas digitais que leem e executam instrues
em linguagem de mquina. No entanto, os humanos consideram a leitura da linguagem de mquina
tediosa, ento, preferimos representar as instrues por um formato simblico denominado
linguagem assembly.
417
Captulo seis Arquitetura
Qual a melhor arquitetura para se estudar Os conjuntos de instrues de diferentes arquiteturas so mais parecidos com diferentes dialetos
quando comear a aprender o assunto? do que diferentes linguagens. Quase todas as arquiteturas definem instrues bsicas, como adio,
subtrao e saltos, que operam em memrias ou registradores. Uma vez que voc tenha aprendido
Arquiteturas comercialmente bem
um conjunto de instrues, entender outros bastante simples.
sucedidas, como a x86, so satisfatrias
para se estudar, pois o leitor pode us-las Uma arquitetura de computador no define a implementao fundamental de hardware.
para escrever programas em Frequentemente, existem muitas implementaes de hardware para uma mesma arquitetura. Por
computadores reais. Infelizmente, muitas exemplo, empresas como a Intel ou a Advanced Micro Devices (AMD), vendem vrios
dessas arquiteturas esto cheias de rugas e
microprocessadores pertencentes mesma arquitetura x86. Todos eles podem rodar os mesmos
idiossincrasias acumuladas ao longo de
programas, mas utilizam diferentes hardwares fundamentais e, portanto, oferecem alternativas em
anos de desenvolvimento bagunado por
diferentes equipes de engenharia,
performance, preo e potncia. Alguns microprocessadores so otimizados para servidores de alta
tornando as arquiteturas difceis de performance, enquanto outros so otimizados para a longa durao de baterias dos laptops. O arranjo
entender e implementar. especfico de registradores, memrias, ALU e outros blocos de construo digitais para formar um
microprocessador chamado de microarquitetura, e ser o assunto do Captulo 7. Frequentemente,
Muitos manuais ensinam arquiteturas
existem muitas microarquiteturas diferentes para uma mesma arquitetura.
imaginrias que so simplificadas para
ilustrar os conceitos chave. Neste texto, introduziremos a arquitetura MIPS, que foi desenvolvida primeiramente por John
Ns seguimos a liderana de David
Hennessy e seus colegas em Stanford, nos anos 80. Os processadores MIPS so utilizados por, dentre
Patterson e John Hennessy no seu livro de outras, pela Silicon Graphics, Nintendo e Cisco. Comearemos introduzindo as instrues bsicas,
texto, Computer Organization and Design, localizao de operandos, e formatos de linguagem de mquina. Em seguida, introduziremos mais
focando na arquitetura MIPS. Centenas de instrues utilizadas em construes comuns de programas, tais como ramos, loops, manipulaes de
milhes de microprocessadores MIPS tm arrays e chamadas de funes.
sido vendidos, tornando essa arquitetura
muito importante comercialmente. No
Ao longo deste Captulo, motivaremos o projeto da arquitetura MIPS utilizando quatro princpios
entanto, uma arquitetura limpa, com um articulados por Patterson e Hennessy: (1) simplicidade favorece a regularidade; (2) tornar o caso
comportamento um pouco diferente. Ao comum rpido; (3) menor mais rpido; e (4) bons projetos demandam bons compromissos.
final deste captulo, visitaremos
brevemente a arquitetura x86 para 6.2. LINGUAGEM ASSEMBLY
compar-la e contrast-la com a MIPS.
A linguagem assembly a representao legvel para humanos da linguagem nativa dos
computadores. Cada instruo da linguagem assembly especifica tanto a operao a ser realizada
418
quanto o operando sobre o qual opera. Introduziremos instrues aritmticas simples e

mostraremos como essas operaes so escritas em linguagem assembly. Em seguida, definiremos
os operandos de instrues MIPS: registradores, memria e constantes.
Este Captulo assume que o leitor j tenha alguma familiaridade com uma linguagem de
programao de alto nvel, como C, C++ ou Java (Essas linguagens so praticamente idnticas para a
maioria dos exemplos neste Captulo, mas quando elas forem diferentes, ns utilizaremos C). O
Apndice C disponibiliza uma introduo linguagem C para aqueles com pouco ou nenhuma
experincia anterior em programao.
6.2.1. Instrues
A operao mais comum que um computador realiza adio. O Exemplo de Cdigo 6.1 mostra
o cdigo para somar duas variveis, b e c, e escrever o resultado em a. O cdigo mostrado na
esquerda numa linguagem de alto nvel (utilizando a sintaxe de C, C++ e Java), e ento reescrito do
lado direito em linguagem assembly MIPS. Note que as declaraes num programa em C terminam
com um ponto e vrgula.
Exemplo de Cdigo 6.1 ADIO
Linguagem de alto nvel Cdigo assembly MIPS
a = b + c; add a, b, c
Exemplo de Cdigo 6.2 SUBTRAO
a = b - c; sub a, b, c
419
A primeira parte numa instruo assembly, add, chamada de mnemnico, e indica qual a
operao a ser realizada. A operao realizada em b e c, os operandos fonte, e o resultado escrito
O mnemnico (pronuncia-ni-mon-ik) vem em a, o operando destino.
da palavra grega , para se
O Exemplo de Cdigo 6.2 mostra que a subtrao similar adio. O formato de instruo o
lembrar. O mnemnico de linguagem de
montagem mais fcil de lembrar do que mesmo que na instruo add, exceto pela especificao da operao, sub. Esse formato consistente
um padro de linguagem de mquina de 0 de informao um exemplo do primeiro princpio de projeto:
e 1. Representando a mesma operao.
Princpio de Projeto 1: Simplicidade favorece a regularidade
Instrues com um nmero consistente de operandos neste caso, duas fontes e um destino - so
mais fceis de codificar e manipular em hardware. Cdigos de alto nvel, mais complexos, so
traduzidos em mltiplas instrues MIPS, como mostrado no Exemplo de Cdigo 6.3.
Nos exemplos com linguagens de alto nvel, comentrios de uma linha iniciam-se com // e
continuam at o final da linha. Comentrios de mltiplas linhas iniciam-se com /* e terminam com
*/. Na linguagem assembly, apenas comentrios de uma nica linha so utilizados. Eles iniciam-se
com # e continuam at ao final da linha. O programa em linguagem assembly no Exemplo de Cdigo
6.3 requer uma varivel temporria t para armazenar o resultado intermedirio. Utilizar mltiplas
instrues em linguagem assembly para realizar operaes mais complexas um exemplo do segundo
princpio de projeto de arquitetura computacional:
Princpio de Projeto 2 Tornar o caso comum rpido
Exemplo de Cdigo 6.3 CDIGO MAIS COMPLEXO
a = b + c - d; //comentrio de linha nica sub t, c, d # t = c d

/* comentrio de add a, b, t # a = b + t
linha mltipla */
420
O conjunto de instrues MIPS faz o caso comum rpido incluindo apenas instrues simples,
comumente utilizadas. O nmero de instrues mantido pequeno para que o hardware necessrio
para decodificar as instrues e seus operandos possa ser simples, pequeno e rpido. Operaes
mais elaboradas, que so menos comuns, so desenvolvidas utilizando sequncias de mltiplas
instrues simples. Portanto, a MIPS possui uma arquitetura de computadores com conjunto de
instrues reduzido (reduced instruction set computer RISC). As arquiteturas com muitas
instrues mais complexas, como a arquitetura x86 da Intel, so computadores com conjunto
complexo de instrues (complex instruction set computers CISC). Por exemplo, na x86 definida
uma instruo de movimento de string que copia uma string (uma srie de caracteres) de uma
parte da memria para outra. Tal operao requer muitas, possivelmente centenas, de instrues
simples numa mquina RISC. No entanto, o custo de implementao de instrues complexas numa
arquitetura CISC somado ao hardware e o sobrecarrega, tornando mais lentas as instrues mais
simples.
Uma arquitetura RISC minimiza a complexidade de hardware e as codificaes de instruo
necessrias, mantendo o conjunto de instrues pequeno. Por exemplo, um conjunto de instrues
com 64 instrues simples precisaria de log 2 64 = 6 bits para codificar a operao. Um conjunto de
instrues com 256 instrues complexas precisaria de log 2 256 = 8 bits de codificao por
instruo. Numa mquina CISC, mesmo que as instrues mais complexas sejam utilizadas apenas
raramente, elas sobrecarregam todas as instrues, mesmo as mais simples.
6.2.2. Operandos: Registradores, Memria e Constantes
Uma instruo opera sobre os operandos. No Exemplo de Cdigo 6.1 as variveis a, b e c so
todas operandos. Mas computadores operam com 1 e 0, no com nomes de variveis. As
instrues necessitam de uma localizao fsica, de onde se possam recuperar os dados binrios.
Operandos podem ser armazenados em registradores ou memria, ou podem ser constantes
armazenadas na prpria instruo. Computadores utilizam vrios locais para colocar os operandos,
de modo a otimizar a velocidade e a capacidade de dados. Operandos armazenados como
constantes ou em registradores so acessados rapidamente, porm, suportam apenas uma
quantidade pequena de dados. Dados adicionais devem ser acessados da memria, que grande,
421
mas lenta. A arquitetura MIPS dita de 32-bits, pois ela opera com dados de 32 (a MIPS tem
sido estendida para 64-bits em produtos comerciais, mas consideraremos apenas a forma de 32
neste livro).
Registradores
Instrues precisam acessar os operandos rapidamente para que eles possam rodar rpido.
Porm, operandos armazenados na memria levam um longo tempo para serem recuperados.
Portanto, a maioria das arquiteturas especfica um pequeno nmero de registradores que podem
manter operandos comumente utilizados. A arquitetura MIPS utiliza 32 registradores, chamados de
conjunto de registradores ou banco de registradores. Quanto menores os registradores, mais rpido
eles podem ser acessados. Isso leva ao terceiro princpio de projeto:
Princpio de Projeto 3: Menor mais rpido
Procurar informaes num nmero pequeno de livros relevantes na sua mesa muito mais rpido
do que procurar nas prateleiras de uma biblioteca. Da mesma forma, ler o dado de um conjunto
pequeno de registradores (por exemplo, 32), mais rpido do que l-los de 1000 registradores ou
de uma grande memria. Um pequeno banco de registradores tipicamente construdo a partir de
um pequeno array SRAM (vide Seo 5.5.3). O array SRAM utiliza um pequeno decodificador e linhas
de bits conectadas a relativamente poucas clulas de memria, criando assim um caminho crtico
menor do que as grandes memrias possuem.
O Exemplo de Cdigo 6.4 mostra a instruo add com operandos registradores. Os nomes dos
registradores MIPS so precedidos pelo smbolo $. As variveis a, b e c so arbitrariamente
colocadas em $s0, $s1 e $s2. O nome $s1 pronunciado como registrador s1 ou dlar s1. A
instruo adiciona os valores de 32 contidos em $s1 (b) e $s2 (c) e escreve o resultado de
32 em $s0 (a).
A arquitetura MIPS geralmente armazena variveis em 18 dos 32 registradores: $s0 - $s7, e

$t0 - $t9. Os registradores com o nome comeando com $s so chamados registradores saved.
De acordo com a conveno MIPS, esses registradores armazenam variveis como a, b e c.
Registradores saved possuem conotaes especiais quando so utilizados em chamadas de funo
422
(vide Seo 6.4.6). Registradores com o nome comeando com $t so chamados de registradores
temporrios. Eles so utilizados para o armazenamento de variveis temporrias. O Exemplo de
Cdigo 6.5 mostra o cdigo em assembly MIPS um registrador temporrio, $t0, para armazenar o
clculo intermedirio de c d.
Exemplo de Cdigo 6.4 OPERANDOS REGISTRADORES
a = b + c; # $s0 = a, $s1 = b, $s2 = c
add $s0, $s1, $s2 # a = b + c
Exemplo de Cdigo 6.5 REGISTRADORES TEMPORRIOS
a = b + c - d; //comentrio de linha nica # $s0 = a, $s1 = b, $s2 = c, $s3 = d

/* comentrio de
linha mltipla */ sub $t0, $s2, $s3 # t = c d
add $s0, $s1, $t0 # a = b + t
Exemplo 6.1 TRADUZINDO CDIGO DE ALTO NVEL PARA LINGUAGEM ASSEMBLY
Traduza o seguinte cdigo de alto nvel em linguagem assembly. Assuma que as variveis a c
esto mantidas nos registradores $s0 - $s2, e f j esto em $s3 - $s7.
a = b c;
f = (g + h) (i + j);
423
Soluo: O programa utiliza quatro instrues em linguagem assembly.

# cdigo assembly MIPS
# $s0 = a, $s1 = b, $s2 = c, $s3 = f, $s4 = g, $s5 = h
# $s6 = i, $s7 = j
sub $s0, $s1, $s2 # a = b c
add $t0, $s4, $s5 # $t0 = g + h
add $t1, $s6, $s7 # $t1 = i + j
sub $s3, $t0, $t1 # f = (g + h) (i + j)
O Conjunto de Registradores
A arquitetura MIPS define 32 registradores. Cada registrador possui um nome e um nmero na
faixa de 0 a 31. A Tabela 6.1 lista o nome, o nmero e o uso de cada registrador. $0 sempre contm
o valor 0, pois essa constante utilizada muito frequentemente em programas de computador.
Ns tambm discutiremos os registradores $s e $t. Os registradores restantes sero descritos ao
longo deste Captulo.
Figura 6.1 Memria enderevel por palavra
424
Tabela 6.1 Conjunto de registradores MIPS
Memria
Se os registradores fossem o nico espao de armazenamento de operandos, ficaramos
confinados a simples programas com no mais de 32 variveis. No entanto, os dados tambm
podem ser armazenados na memria. Quando comparada com o banco de registradores, a memria
possui muito mais locais de dados, mas acess-los leva uma grande quantidade de tempo. Enquanto
o banco de registradores pequeno e rpido, a memria grande e lenta. Por essa razo, variveis
comumente utilizadas so mantidas em registradores. Atravs do uso combinado de memria e
registradores, um programa pode acessar uma grande quantidade de dados bem rpido. Como
descrito na Seo 5.5 as memrias so organizadas num array de palavras de dados. A arquitetura
MIPS utiliza endereos de memria de 32-bits e palavras de 32-bits.
425
A MIPS utiliza memria enderevel por byte. Isto , cada byte na memria possui um nico
endereo. No entanto, apenas para propsitos de explicao, primeiro introduziremos uma memria
enderevel por palavra e, mais tarde, descreveremos a memria enderevel por byte da MIPS.
A Figura 6.1 mostra um array de memria que enderevel por palavra. Isto , cada dado de 32-
bits possui um nico endereo de 32-bits. Tanto a palavra de endereo de 32-bits quanto o dado de
32-bits so escritos em hexadecimal na Figura 6.1. Por exemplo, o dado 02107 armazenado
no endereo de memria 1. Constantes hexadecimais so escritas com o prefixo 0. Por conveno,
a memria escrita com os endereos mais baixos da memria na parte de baixo e os endereos
maiores para cima.
A MIPS utiliza a instruo de carregamento de palavra (load word), lw, para ler uma palavra de
dado da memria num registrador. O Exemplo de Cdigo 6.6 carrega a palavra de memria 1 em $s3.
A instruo lw especifica o endereo efetivo na memria como a soma de um endereo de base e

um offset. O endereo de base (escrito entre parnteses na instruo) um registrador. O offset
uma constante (escrita antes dos parnteses). No Exemplo de Cdigo 6.6, o endereo de base $0,
que mantm o valor 0, e o offset 1, ento a instruo lw l do endereo de memria ($0+1) =
1. Aps a instruo de carregamento de palavra (lw) ser executada, $s3 mantm o valor
02107, o qual o valor do dado armazenado no endereo de memria 1 da Figura 6.1.
Exemplo de Cdigo 6.6 LENDO UMA MEMRIA ENDEREVEL POR PALAVRA
Cdigo Assembly
# Este cdigo assembly (diferente de MIPS) assume uma memria enderevel por palavra
lw $s3, 1($0) # l a palavra de memria 1 dentro de $s3
426
Exemplo de Cdigo 6.7 ESCREVENDO NUMA MEMRIA ENDEREVEL POR PALAVRA
Cdigo Assembly
# Este cdigo assembly (diferente de MIPS) assume uma memria enderevel por palavra
sw $s7, 5($0) # escreve $s7 na palavra de memria 5
Figura 6.2 Memria enderevel por byte
Similarmente, a MIPS utiliza a instruo de armazenamento de palavra, sw, para escrever uma
palavra de dado de um registrador na memria. O Exemplo de Cdigo 6.7 escreve o contedo do
registrador $s7 na palavra de memria 5. Estes exemplos tm utilizado $0 como endereo de base
por simplicidade, mas lembre-se que qualquer registrador pode ser utilizado para alimentar o
endereo de base.
Os dois exemplos de cdigo anteriores tm mostrado uma arquitetura computacional com uma
memria enderevel por palavra. O modelo de memria MIPS , no entanto, enderevel por byte,
e no enderevel por palavra. Cada byte de dado possui um nico endereo. Uma palavra de 32-
427
bits consiste em quatro bytes de 8-bits. Ento, cada palavra de endereo um mltiplo de 4, como
mostrado na Figura 6.2. Novamente, tanto a palavra de endereo de 32 quanto o valor do
dado so dados em hexadecimal.
O Exemplo de Cdigo 6.8 mostra como ler e escrever palavras numa memria MIPS enderevel
por byte. A palavra de endereo igual a quatro vezes o nmero da palavra. O cdigo assembly MIPS
l as palavras 0, 2 e 3 e escreve as palavras 1, 8 e 100. O offset pode ser escrito em decimal ou em
hexadecimal.
A arquitetura MIPS tambm fornece as instrues lb e sb, que carregam e armazenam bytes
individuais na memria, ao invs de palavras. Eles so similares a lw, e sw, e sero discutidos mais
profundamente na Seo 6.4.5.
Memrias endereveis por byte so organizadas nos estilos big-endian e little-endian, como
mostrado na Figura 6.3. Em ambos os formatos, o byte mais significativo (MSB) est esquerda, e o
byte menos significativo (LSB) est direita. Em mquinas big-endian, os bytes so numerados
Figura 6.3 Endereamentos de comeando com 0 no byte mais significativo (big end). Em mquinas little-endian, os bytes so
memria big- e little-endian numerados partindo do zero no menos significativo (little end). Os endereos de palavras so os
mesmos em ambos os formatos e referem-se aos mesmos quatro bytes. Apenas os endereos dos
bytes dentro de uma mesma palavra diferem.
Exemplo de Cdigo 6.8 ACESSANDO A MEMRIA ENDEREVEL POR BYTE
Cdigo assembly MIPS
lw $s0, 0($0) # l a palavra de dado 0 (0xABCDEF78) em $s0

lw $s1, 8($0) # l a palavra de dado 2 (0x01EE2842) em $s1
lw $s2, OxC($0) # l a palavra de dado 3 (0x40F30788) em $s2
sw $s3, 4($0) # escreve $s3 para a palavra de dado 1
sw $s4, 0x20($0) # escreve $s4 para a palavra de dado 8
sw $s5, 400($0) # escreve $s5 para a palavra de dado 100
428
Exemplo 6.2 MEMRIAS BIG- E LITTLE-ENDIAN
Suponha que $s0 inicialmente contm 023456789. Aps rodar o programa a seguir num
sistema big-endian, qual o valor contido em $s0? E num sistema little-endian? lb $s0, 1($0)
carrega o dado do byte de endereamento (1+$0) = 1 para o byte menos significativo de $s0.
lb ser discutido em detalhes na Seo 6.4.5.
sw $s0, 0($0)
lb $s0, 1($0) Os termos big-endian e little-endian vm
das Viagens de Gulliver de Jonathan Swift,
Soluo: A Figura 6.4 mostra como as mquinas big- e little-endian armazenam o valor 023456789
publicadas pela primeira vez em 1726 sob o
na palavra de memria 0. Aps a instruo de carregamento de byte, lb $s0, 1 ($0), $s0 pseudnimo de Isaac Bickerstaff. Em suas
deveria conter 000000045 num sistema big-endian e 000000067 num sistema little-endian. histrias o rei Lilliputian exigia que os seus
cidados (os Little-Endians) quebrassem os
ovos do lado pequeno. Os big-endians eram
os rebeldes que quebravam os seus ovos do
lado grande. Os termos foram usados pela
primeira vez na arquiteturas de
computadores por Danny Cohen no seu
artigo " On Holy Wars and a Plea for Peace
Figura 6.4 Armazenamento de dados big- e Little-endian ", publicado em Abril de 1980 (USC / ISI IEN
137). (Foto cedida por The Brotherton
A PowerPC da IBM (antigamente encontrada em computadores Macintosh) utiliza
Collection, IEEDS University Library.)
endereamento big-endian. A arquitetura Intel x86 (encontrada em PC) utiliza endereamento little-
endian. Alguns processadores MIPS so little-endian, e alguns so big-endian. A escolha
completamente arbitrria, mas leva a dificuldades quando dados so compartilhados entre
computadores big-endian e little-endian. Nos exemplos deste texto, utilizaremos o formato little-
endian sempre que a ordem dos bytes for importante.
429
Na arquitetura MIPS, os endereos para lw e sw devem ser alinhados. Ou seja, o endereo deve
ser divisvel por 4. Assim, a instruo lw $s0, 7 ($0) uma instruo ilegal. Algumas
arquiteturas, como a x86, permitem a leitura e escrita de dados de palavras no alinhadas, mas a
MIPS requer um rigoroso alinhamento, por simplicidade. claro, bytes de endereos para carregar
um byte ou armazenar um byte, lb e sb, no precisam ser alinhados.
Constantes / Imediatos
As instrues de carregamento e armazenamento de palavras, lw e sw, tambm ilustram o uso

de constantes em instrues MIPS. Essas constantes so chamadas de imediatos, pois seus valores
esto imediatamente disponveis a partir da instruo, e no necessrio nenhum registrador ou
acesso memria. Adicionar imediato, addi, outra instruo MIPS comum, que utiliza um
operando imediato. addi adiciona o imediato especificado na instruo ao valor num registrador,
como mostrado no Exemplo de Cdigo 6.9.
Exemplo de Cdigo 6.9 OPERANDOS IMEDIATOS
Cdigo de Alto nvel Cdigo assembly MIPS
a = a + 4; # $s0 = a, $s1 = b
b = a 12; addi $s0, $s0, 4 # a = a + 4
addi $s1, $s0, 12 # b = a 12
O imediato especificado numa instruo um nmero de 16-bits, complemento-2, na faixa

entre 32,768 a 32,767. A subtrao equivalente adio de um nmero negativo, ento, no
interesse da simplicidade, no existe uma instruo subi na arquitetura MIPS.
Lembre-se que as instrues add e sub utilizam trs operandos registradores. Mas as instrues
lw, sw e addi utilizam dois operandos registradores e uma constante. Devido aos formatos das
instrues serem diferentes, as instrues lw e sw violam o princpio de projeto 1: simplicidade
favorece regularidade. No entanto, este problema permite introduzir o prximo princpio de
projeto:
430
Princpio de projeto 4: Bons projetos demandam bons compromissos

Um nico formato de instruo poderia ser simples, mas no flexvel. O conjunto de instrues MIPS
faz o compromisso de suportar trs formatos de instruo. Um formato, utilizado por instrues como
add e sub, possui trs operandos registradores. Outra, utilizada por instrues como lw e addi,
possui dois operandos registradores e um imediato de 16-bits. Uma terceira, que ser discutida
posteriormente, possui um imediato de 26-bits e no possui registradores. A prxima Seo discute os
trs formatos de instruo MIPS e mostra como eles so codificados em binrio.
6.3. LINGUAGEM DE MQUINA

A linguagem assembly conveniente para ser lida por seres humanos. No entanto, circuitos digitais
entendem apenas 1 e 0. Portanto, um programa escrito em linguagem assembly traduzido de
mnemnicos para uma representao utilizando apenas 0 e 1 denominada linguagem de mquina.
A arquitetura MIPS utiliza instrues de 32-bits. Novamente, simplicidade favorece a regularidade,
e a escolha mais regular a de codificar todas as instrues em palavras que possam ser armazenadas
na memria. Apesar de algumas instrues no necessitarem de 32-bits de codificao, instrues de
comprimento varivel podem adicionar muita complexidade. A simplicidade tambm encoraja um
formato de instruo individual, mas, como mencionado anteriormente, isso muito restritivo. A MIPS
faz o compromisso de definir trs formatos de instruo: Tipo-R, Tipo-I e Tipo-J. Esse pequeno nmero
de formatos proporciona certa regularidade entre todos os tipos e, portanto, um hardware mais
simples, e ao mesmo tempo incorporam diferentes necessidades de instruo, como a de codificar
grandes constantes na instruo. Instrues tipo-R operam em trs registradores. Instrues tipo-I
operam em dois registradores e um imediato de 16-bits. Instrues tipo-J (jump) operam num imediato
de 26-bits. Introduziremos todos os trs formatos nessa Seo, mas deixaremos a discusso das
instrues tipo-J para a Seo 6.4.2.
431
6.3.1. Instrues Tipo-R

O nome tipo-R uma abreviao para tipo registrador. Instrues tipo-R utilizam trs
registradores como operandos: dois como fonte e um como destino. A Figura 6.5 mostra o formato
de instruo de mquina tipo-R. a instruo de 32-bits possui seis campos: op, rs, rt, rd, shamt
e funct. Cada campo de cinco ou seis bits, como indicado.
Figura 6.5 Formato de instruo de mquina
A operao que a instruo realiza codificada nos dois campos destacados em azul: op
(tambm chamado opcode, ou cdigo de operao) e funct (tambm chamado de funo).
Todas as instrues tipo-R possuem um opcode de 0. A operao especfica tipo-R determinada
pelo campo field. Por exemplo, os campos opcode e funct para a instruo add so
0 (0000002 ) e 32 (1000002 ), respectivamente. Similarmente, a instruo sub possui os campos
opcode e funct de 0 e 34.
Os operandos so codificados em trs campos: rs, rt e rd. Os primeiros dois registradores, rs

e rt, so os registradores fonte; rd o registrador de destino. Os campos contm o nmero de
registradores que foram dados na Tabela 6.1. Por exemplo, $s0 o registrador 16.
O quinto campo, shamt, utilizado apenas em operaes de deslocamento. Nestas instrues,

o valor binrio armazenado no campo de 5-bits shamt indica a quantidade do deslocamento. Para
todas as outras instrues tipo-R, shamt 0.
A Figura 6.6 mostra o cdigo de mquina para as instrues tipo-R add e sub. Note que o
destino o primeiro registrador numa instruo de linguagem assembly, mas o terceiro campo
numa instruo de linguagem de mquina. Por exemplo, a instruo em assembly add $s0,
$s1, $s2 tem rs = $s1 (17), rt = $s2 (18), e rd = $s0 (16).
432
Para as instrues MIPS utilizadas neste livro, as Tabela B.1 e Tabela B.2 no apndice Erro! A origem
da referncia no foi encontrada. definem os valores dos opcodes para todas as instrues e os
valores do campo funct para instrues tipo-R.
Figura 6.6 Cdigo de mquina para instrues Tipo-R
Exemplo 6.3 TRADUZINDO LINGUAGEM ASSEMBLY EM LINGUAGEM DE MQUINA

Traduza em linguagem de mquina a seguinte declarao em linguagem assembly.
add $t0, $s4, $s5
Soluo: De acordo com a Tabela 6.1 , $t0, $s4 e $s5 so os registradores 8, 20 e 21. De acordo com
as Tabela B.1 e Tabela B.2, add possui um opcode de 0 e um cdigo funct de 32. Assim, os campos
e o cdigo de mquina so dados na Figura 6.7. O modo mais fcil de escrever a linguagem de mquina
em hexadecimal primeiro escrev-la em binrio, e ento separ-la em grupos consecutivos de 4-bits,
os quais correspondem a dgitos hexadecimais (indicados em azul). Consequentemente, a instruo
em linguagem de mquina 002954020.
Figura 6.7 Cdigo de mquina para instrues tipo-R do Exemplo 6.3
6.3.2. Instrues Tipo-I

O nome Tipo-I uma abreviao para tipo imediato. Instrues tipo-I utilizam dois operandos
registradores e um operando imediato. A Figura 6.8 mostra o formato de instruo de mquina tipo-I.
433
A instruo de 32-bits possui quatro campos: op, rs, rt e imm. Os primeiros trs campos, op, rs e
rt, so como aquelas instrues do tipo-R. o campo imm mantm um imediato de 16 .
rs uma abreviao para "register
A operao determinada exclusivamente pelo opcode, destacado em azul. Os operandos so
source". rt vem alfabeticamente aps
especificados em trs campos, rs, rt e imm. rs e imm so sempre utilizados como operandos fonte.
rs, e usualmente indica o segundo
rt utilizado como destino por algumas instrues (como addi e lw), mas tambm como outra
registrador fonte.
fonte por outras (como sw).
A Figura 6.9 mostra muitos exemplos de codificao de instrues tipo-I. Lembre-se que valores
negativos em imediatos so representados utilizando-se notao de 16-bits com complemento-2.
Numa instruo de linguagem assembly, rt listado primeiro, quando utilizado como destino, mas
o segundo campo de registrador numa instruo de linguagem de mquina.
Figura 6.8 Formato de instruo tipo-I
Figura 6.9 Cdigo de mquina para instrues tipo-I
434
Exemplo 6.4 TRADUZINDO INSTRUES ASSEMBLY TIPO-I EM CDIGO DE MQUINA

Traduza a seguinte instruo tipo-I em cdigo de mquina.
lw $s3, -24 ($s4)
Soluo: De acordo com a Tabela 6.1, $s3 e $s4 so os registradores 19 e 20, respectivamente. A
Tabela B.1 indica que lw possui um opcode de 35. rs especifica o endereo de base, $s4, e rt
especifica o registrador de destino, $s3. O imediato, imm, codifica o offset de 16-bits, 24. Os campos
e os cdigos de mquina so dados na Figura 6.10.
Figura 6.10 Cdigo de mquina para uma instruo tipo-I
Instrues tipo-I possuem um campo de imediato de 16-bits, mas os imediatos so utilizados em

operaes de 32 . Por exemplo, lw adiciona um offset de 16-bits a um registrador de base de 32-
bits. O que deveria ir parte superior dos 32-bits? Para imediatos positivos, a parte superior deveria
estar toda de 1. Lembre-se, da Seo 1.4.6, que isso chamado de extenso de sinal. Um nmero de
N-bits em complemento-2 tem o sinal estendido para um nmero de M-bits (M > N) copiando-se o bit
de sinal (bit mais significativo) do nmero de N-bits para todos os bits superiores do nmero de M-bits.
Estendendo-se o sinal de um nmero em complemento-2 no muda o seu valor.
A maioria das instrues MIPS estende o sinal do imediato. Por exemplo addi, lw e sw fazem
extenso de sinal para suportar tanto imediatos positivos quanto negativos. Uma exceo a essa regra
que operaes lgicas (andi, ori, xori) pem 0 na parte superior; isso chamado extenso de
zeros ao invs de extenso de sinal. Operaes lgicas sero melhor discutidas na Seo 6.4.1.
435
6.3.3. Instrues Tipo-J

O nome tipo-J uma abreviao para tipo salto (jump). Esse formato utilizado apenas em
instrues de salto (vide Seo 6.4.2). Esse formato de instruo utiliza um nico operando de
endereo de 26-bits, addr, como mostrado na Figura 6.11. Assim como outros formatos, as
instrues tipo-J iniciam-se com um opcode de 6 bits. Os bits remanescentes so utilizados para
especificar o endereo, addr. Uma discusso mais profunda e alguns exemplos e cdigos de
mquina de instrues tipo-J sero dados nas Sees 6.4.2 e 6.5.
6.3.4. Interpretando Cdigos em Linguagem de Mquina
Para interpretar linguagem de mquina, primeiro devem-se decifrar os campos em cada palavra
de instruo de 32-bits. Diferentes instrues utilizam diferentes formatos, mas todos os formatos
iniciam-se com um campo de opcode de 6-bits. Se ele 0, a instruo do tipo-R. Caso contrrio, ele
do tipo-I ou do tipo-J.
Exemplo 6.5 TRADUZINDO LINGUAGEM DE MQUINA EM LINGUAGEM ASSEMBLY

Traduza o seguinte cdigo em linguagem de mquina para linguagem assembly.
022371
00234022
Soluo: Primeiramente, ns representamos cada instruo em binrio e ento olhamos os seis bits
mais significativos para encontrar o opcode de cada instruo, como mostrado na Figura 6.12. O
opcode determina como interpretar os bits restantes. Os opcodes so 0010002 (810 ) e 0000002
(010 ), indicando uma instruo addi e uma instruo tipo-R, respectivamente. O campo funct da
instruo tipo-R 1000102 (3410 ), indicando uma instruo sub. A Figura 6.12 mostra o cdigo
assembly equivalente para as duas instrues de mquina.
6.3.5. A Potncia do Programa Armazenado

Um programa escrito em linguagem de mquina uma srie de nmeros de 32-bits que
representam as instrues. Assim como outros nmeros binrios, essas instrues podem ser
armazenadas na memria. Esse o conceito de programa armazenado, e uma razo chave do
436
porqu de os computadores serem to poderosos. Rodar um programa diferente no requer grandes

quantidades de tempo e esforo para reconfigurar ou remontar o hardware; apenas requer a escrita
de um novo programa na memria. Ao invs de hardware dedicado, o programa armazenado oferece
computao de propsito geral. Desse modo, um computador consegue executar aplicaes que vo
de uma calculadora a um processador de texto ou a um player de vdeo, apenas mudando o programa
armazenado.
Instrues num programa armazenado so recuperadas, ou buscadas, na memria e executadas no
processador. Mesmo programas grandes e complexos so simplificados numa srie de leituras de
memria e execuo de instrues.
Figura 6.11 Formato de instruo tipo-J
Figura 6.12 Traduo de cdigo de mquina para cdigo assembly
A Figura 6.13 mostra como as instrues de mquina so armazenadas na memria. Em programas

MIPS, as instrues so normalmente armazenadas partindo do endereo 000400000. Lembre-se
que a memria MIPS enderevel por byte, ento, instrues de 32-bits (4-bytes) avanam 4 bytes,
no 1.
437
Para rodar ou executar o programa armazenado, o processador busca as instrues na memria

sequencialmente. As instrues buscadas so ento descodificadas e executadas pelo hardware
digital. O endereo da instruo atual mentido num registrador de 32 chamado contador de
programa (program counter - PC). O PC separado dos 32-registradores mostrados anteriormente
na Tabela 6.1.
Para executar o cdigo na Figura 6.13, o sistema operacional coloca no PC o endereo
000400000. O processador l a instruo naquele endereo de memria e executa a instruo
0800020. O processador ento incrementa o PC em 4, para 000400004, recuperando e
executando aquela instruo, e se repete.
O estado arquitetural de um microprocessador mantm o estado de um programa. Para a MIPS, o
estado arquitetural consiste num banco de registradores e o PC. Se o sistema operacional salva o
estado arquitetural em algum ponto de um programa, ele pode interromper o programa, fazer outra
coisa, e, em seguida retornar ao estado, tal que o programa continue corretamente, sem notar que
ele tenha sido interrompido alguma vez. O estado arquitetural ser tambm de grande importncia
quando ns construirmos um microprocessador no Captulo 7.
Figura 6.13 Programa armazenado
438
6.4. PROGRAMANDO
Linguagens de software, tais como C ou Java, so chamadas linguagens de programao de alto
nvel, pois so escritas num nvel maior de abstrao do que a linguagem assembly. Muitas linguagens
de alto nvel utilizam construtores de software comuns, como operaes lgicas e aritmticas,
declaraes if/else, loops for e while, indexao de arrays e chamadas de funo. Veja o
Apndice C para mais exemplos desses construtores em C. Nesta Seo, exploraremos como traduzir
esses construtores de alto nvel em cdigo assembly MIPS.
6.4.1. Instrues Aritmticas/Lgicas
A arquitetura MIPS define uma variedade de instrues lgicas e aritmticas. Definimos
brevemente essas instrues aqui, pois elas so necessrias para implementar construtores de nveis
mais altos.
Instrues Lgicas
Operaes lgicas MIPS incluem and, or, xor e nor. Essas instrues tipo-R operam bit a bit em
Ada Lovelace, 1815 - 1852
dois registradores fonte e escrevem o resultado num registrador destino. A Figura 6.14 mostra
exemplos dessas operaes com os dois valores fonte, 00000 e 046107. A figura Escreveu o primeiro programa de
mostra os valores armazenados no registrador destino, rd, aps a execuo da instruo. computador, que calculava os nmeros de
Bernoulli utilizando a mquina analtica de
A instruo and til para mascarar os bits (isto , forar bits indesejados para o valor 0). Por Charles Babbage. Ela foi a nica criana
exemplo, na Figura 6.14, 00000 046107 = 04610000. A instruo and legtima do poeta Lord Byron.
mascara os dois bytes inferiores e coloca os dois bytes superiores de $s2, 0461, em $s3.
Qualquer subconjunto de bits de registradores pode ser mascarado.
A instruo or til para combinar bits de dois registradores. Por exemplo, 03470000 OR
0000072 = 034772, uma combinao dois dois valores.
A arquitetura MIPS no disponibiliza uma instruo , mas $0 = , ento a
instruo pode ser uma substituta.
439
Figura 6.14 Programa armazenado
Operaes lgicas tambm podem ser operadas em imediatos. As instrues, do tipo-I, so:
andi, ori e xori. A instruo nori no disponibilizada, pois essa mesma funo pode ser
facilmente implementada utilizando-se outras instrues, como ser explorado no Exerccio 6.16.
A Figura 6.15 mostra exemplos das instrues andi, ori e xori. A figura d os valores do
registrador fonte e imediato e o valor do registrador destino, rt, aps a instruo ser executada.
Devido a estas instrues operarem num valor de 32-bits vindo de um registrador e um imediato
de 16-bits, elas primeiro estendem em zeros o imediato, para 32-bits.
Figura 6.15 Operaes lgicas com imediatos
440
Instrues de Deslocamento
Instrues de deslocamento deslocam o valor de um registrador para a esquerda ou para a direita
em at 31-bits. Operaes de deslocamento multiplicam ou dividem por potncias de dois. As
operaes MIPS de deslocamento so: sll (shift left logical deslocamento lgico esquerda), srl
(shift right logical deslocamento lgico direita), e sra (shift right aritmetic deslocamento
aritmtico direita).
Como discutido na Seo 5.2.5, deslocamentos esquerda sempre preenchem os bits menos
significativos com 0. No entanto, deslocamentos direita podem ser tanto lgicos (deslocamento
de 0 para os bits mais significativos) ou aritmticos (o bit de sinal se desloca para os bits mais
significativos). A Figura 6.16 mostra o cdigo de mquina para as instrues tipo-R, sll, srl e sra.
rt (isto , $s1) mantm o valor de 32-bits a ser deslocado, e shamt d o valor do deslocamento
(4). O valor deslocado colocado em rd.
A Figura 6.17 mostra os valores de registradores para as instrues de deslocamento sll, srl e
sra. Deslocando um valor de N esquerda equivalente a multiplica-lo por 2 . Do mesmo modo,
deslocar aritmeticamente um valor para N posies direita equivalente a dividi-lo por 2 , como
discutido na Seo 5.2.5.
A arquitetura MIPS tambm possui instrues de deslocamento de variveis: sllv (shift left
logical variable deslocamento de varivel lgica esquerda), srlv (shift right logical variable
deslocamento de varivel lgica direita), e srav (shift right arithmetic variable deslocamento
aritmtico de varivel direita). A Figura 6.18 mostra o cdigo de mquina para essas instrues.
Instrues em assembly de deslocamento de variveis so da forma sllv, rd, rt, rs. A ordem de
rt e rs invertida em comparao maioria das instrues tipo-R. rt ($s1) mantm o valor a
ser deslocado, e os quatro bits menos significativos de rs ($s2) do o tamanho do deslocamento.
O resultado deslocado colocado em rd, como antes. O campo shamt ignorado e deve ser todo
composto por 0. A Figura 6.19 mostra os valores de registradores para cada tipo de instruo de
deslocamento de varivel.
441
Figura 6.16 Cdigos de mquina da instruo de deslocamento
Figura 6.17 Operaes de deslocamento
Figura 6.18 Cdigo de mquina para instruo de deslocamento varivel
442
o tipo de dado int em C refere-se a uma

palavra com representao de dados
inteiros em complemento-2. a MIPS utiliza
palavras de 32-bits, ento um int
representa um nmero na faixa
[231 , 231 1].
Figura 6.19 Operaes de deslocamento varivel
Gerando Constantes
A instruo addi til para atribuir constantes de 16-bits, como mostrado no Exemplo de Cdigo
6.10.
Exemplo de Cdigo 6.10 CONSTANTE DE 16-BITS
Cdigo de Alto Nvel Cdigo assembly MIPS
int a = 0x4f3c; # $s0 = a

addi $s0, $0, 0x4f3c # a = 0x4f3c
Para atribuir constantes de 32-bits, utilizada uma instruo de carregamento do imediato

superior (load upper imediate lui), seguida por uma instruo do imediato (ori), como
mostrado no Exemplo de Cdigo 6.11. A instruo lui carrega um imediato de 16-bits na metade
superior de um registrador e coloca a metade inferior a 0. Como mencionado anteriormente, ori
funde um imediato de 16-bits com a metade superior.
443
Exemplo de Cdigo 6.11 CONSTANTE DE 32-BITS
int a = 0x6d5e4f3c; # $s0 = a

lui $s0, 0x6d5e # a = 0x6d5e0000
ori $s0, $s0, 0x4f3x # a = 0x6d5e4f3c
Instrues de Multiplicao e Diviso*
A multiplicao e a diviso so um pouco diferentes de outras operaes aritmticas.

Multiplicando-se dois nmeros de 32 , produzido um quociente de 32-bits e um resto de
32-bits.
A arquitetura MIPS possui dois registradores de propsitos especiais, hi e lo, os quais so

utilizados para manter os resultados das multiplicaes e divises. A instruo mult $s0, $s1
multiplica os valores em $s0 e $s1. Os 32-bits mais significativos do produto so colocados em
hi e os 32-bits menos significativos so colocados em lo. Similarmente, div $s0, $s1
computa $s0/s1. O quociente colocado em lo e o resto colocado em hi.
A MIPS disponibiliza outra instruo de multiplicao que produz um resultado de 32-bits em

um registrador de propsito geral. mul $s1,$s2,$s3 multiplica os valores em $s2 e $s3 e
coloca o resultado de 32 em $s1.
444
6.4.2. Desvios (Branching)

Uma vantagem de um computador sobre uma calculadora sua habilidade de tomar decises.
hi and lo no esto entre os 32 registradores
Um computador realiza diferentes tarefas, dependendo da entrada. Por exemplo, declaraes
MIPS usuais, ento instrues especiais so
if/else, declaraes switch/case, loops while e loops for, todos eles executam
necessrias para acess-los. mfhi $s2 (move
condicionalmente um cdigo, dependendo de algum teste. de hi) copia o valor em hi para $s2. mflo
Para executar instrues sequencialmente, o contador de programa incrementado em 4 aps $s3 (move de lo) copia o valor em lo para
$s3. hi e lo so, tecnicamente, parte do
cada instruo. Instrues do tipo branch (ramificao) modificam o contador de programa a fim de
estado arquitetural. No entanto, ns
pular sees de cdigo ou repetir cdigos anteriores. Instrues de branch condicional realizam um
geralmente ignoramos esses registradores
teste e o programa desviado se o teste for TRUE. Instrues de branch incondicional, chamadas neste livro.
jumps ou saltos, sempre fazem o programa ser desviado.
Desvios Condicionais
O conjunto de instrues MIPS possui duas instrues de desvios condicionais: desviar se igual
(branch if equal beq), e desviar se no igual (branch if note qual bne). A instruo beq desvia
o programa quando os valores nos dois registradores so iguais, e a instruo bne desvia quando
eles no so iguais. O Exemplo de Cdigo 6.12 ilustra o uso da instruo beq. Note que os desvios
so escritos como beq rs, rt, imm, onde rs o primeiro registrador fonte. Para a maioria das
instrues tipo-I, essa ordem invertida.
Quando o programa do Exemplo de Cdigo 6.12 alcana o desvio da instruo se igual (beq),
o valor em $s0 igual ao valor em $s1, ento o desvio realizado. Isto , a prxima instruo a
ser executada a instruo add logo aps o label (rtulo) chamado target. As duas instrues
diretamente aps o desvio e antes da label no so executadas.
O cdigo assembly utiliza labels para indicar as localizaes das instrues no programa. Quando
o cdigo assembly traduzido em linguagem de mquina, essas labels so traduzidos em endereos
de instrues (veja a Seo 5.5). As labels da linguagem assembly so seguidas de dois pontos (:) e
no podem utilizar palavras reservadas, como mnemnicos de instruo. A maioria dos
programadores indenta as suas instrues, mas no as labels, para ajudar a destaca-las.
445
O Exemplo de Cdigo 6.13 mostra um exemplo de utilizao do desvio com a instruo se no

igual (bne). Nesse caso, o desvio no feito, pois $s0 igual a $s1, e o cdigo continua a ser
executado diretamente aps a instruo bne. Todas as instrues nesse fragmento de cdigo so
executadas.
Exemplo de Cdigo 6.12 DESVIO CONDICIONAL UTILIZANDO BEQ
Cdigo assembly MIPS
addi $s0, $0, 4 # $s0 = 0 + 4 = 4

addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
beq $s0, $s1, target # $s0 == $s1, o desvio tomado
addi $s1, $s1, 1 # no executado
sub $s1, $s1, $s0 # no executado
target:
add $s1, $s1, $s0 # $s1 = 4 + 4 = 8
Exemplo de Cdigo 6.13 DESVIO CONDICIONAL UTILIZANDO BNE
Cdigo assembly MIPS
addi $s0, $0, 4 # $s0 = 0 + 4 = 4

addi $s1, $0, 1 # $s1 = 0 + 1 = 1
s11 $s1, $s1, 2 # $s1 = 1 << 2 = 4
bne $s0, $s1, target # $s0 == $s1, o desvio no tomado
addi $s1, $s1, 1 # $s1 = 4 + 1 = 5
sub $s1, $s1, $s0 # $s1 = 5 4 = 1
446
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5
Salto j e jal so instrues do tipo-J. jr

Um programa pode, incondicionalmente, fazer um salto, utilizando os trs tipos de instrues: uma instruo do tipo-R, que utiliza
salto (jump j), salto e ligao (jump and link jal), e salto e registro (jump and register jr). apenas o operando rs.
A instruo jump (j) salta diretamente para a instruo especificada na label. A instruo jal
similar j, mas utilizada por funes para salvar um endereo de retorno, como ser discutido
na Seo 6.4.6. A instruo jr salta para o endereo mantido no registrador. O Exemplo de Cdigo
6.14 mostra o uso da instruo jump (j).
Aps a instruo j target, o programa no Exemplo de Cdigo 6.14 incondicionalmente

continua a executar a instruo add no label target. Todas as instrues entre o salto e o
label so ignoradas.
Exemplo de Cdigo 6.14 DESVIO INCONDICIONAL UTILIZANDO J
Cdigo assembly MIPS
addi $s0, $0, 4 # $s0 = 4

addi $s1, $0, 1 # $s1 = 1
j target # salta para target
addi $s1, $s1, 1 # no executado
sub $s1, $s1, $s0 # no executado
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5
447
Exemplo de Cdigo 6.15 DESVIO INCONDICIONAL UTILIZANDO JR
Cdigo assembly MIPS
0x00002000 addi $s0, $0, 0x2010 # $s0 = 0x2010

0x00002004 jr $s0 # jump to 0x00002010
0x00002008 addi $s1, $0, 1 # no executado
0x0000200c sra $s1, $s1, 2 # no executado
0x00002010 lw $s3, 44($s1) # executado aps instruo jr
O Exemplo de Cdigo 6.15 mostra o uso da instruo de salto de registrador (jr). Os endereos
das instrues so dados esquerda de cada instruo jr $s0 salta para o endereo armazenado
em $s0, 000002010.
6.4.3. Declaraes Condicionais
Declaraes if, if/else e switch/case so declaraes condicionais comumente utilizadas
em linguagens de alto-nvel. Cada uma delas executa um bloco de cdigo, consistindo de uma ou mais
declaraes. Esta Seo mostra como traduzir essas construes de alto nvel em linguagem assembly
MIPS.
Declaraes If
Uma declarao if executa um bloco de cdigo, o bloco if, apenas se uma condio alcanada.
O Exemplo de Cdigo 6.16 mostra como traduzir uma declarao if em cdigo assembly MIPS.
448
Exemplo de Cdigo 6.16 DECLARAO IF
Linguagem de Alto Nvel Cdigo assembly MIPS
if (i = = j) # $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j

f = g + h; bne $s3, $s4, L1 # se i != j, salta bloco if
add $s0, $s1, $s2 # bloco if: f = g + h
f = f i;
L1:
sub $s0, $s0, $s3 # f = f i
O cdigo assembly para a declarao if testa a condio oposta quela no cdigo de alto nvel.
No Exemplo de Cdigo 6.16, a linguagem de alto nvel testa se i == j, e o cdigo assembly testa
se i != j. A instruo bne desvia (ignora o bloco if) quando i != j. Caso contrrio, i ==
j, o desvio no realizado, e o bloco if executado como desejado.
Declaraes If/else
Declaraes if/else executam um dos dois blocos de cdigo, dependendo de uma condio.
Quando a condio na declarao if alcanada, o bloco if executado. De outro modo, o bloco
else executado. O Exemplo de Cdigo 6.17 mostra um exemplo de declaraes if/else.
Assim como as declaraes if, o cdigo assembly para if/else testa a condio oposta
quela no cdigo de alto nvel. Por exemplo, no Exemplo de Cdigo 6.17, o cdigo de alto nvel
testa se i==j. O cdigo assembly testa a condio contrria (i != j). Se a condio oposta
TRUE, a instruo bne ignora o bloco if e executa o bloco else. Caso contrrio, o bloco if
executado e termina com a instruo de salto (j), para pular o bloco else.
449
Exemplo de Cdigo 6.17 DECLARAO IF/ELSE
if (i = = j) # $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j

f = g + h; bne $s3, $s4, else # se i != j, salta para
else
else add $s0, $s1, $s2 # bloco if: f = g + h
f = f i; j L2 # pula o bloco else
else:
sub $s0, $s0, $s3 # bloco else: f = f i
L2:
Declaraes switch/case*
Declaraes switch/case executam um bloco de cdigo dentre muitos, dependendo das

condies. Se nenhuma condio foi alcanada, o bloco default executado. Uma declarao
case equivalente a uma srie de declaraes if/else umas dentro das outras. O Exemplo de
Cdigo 6.18 mostra dois fragmentos de cdigos de alto nvel com a mesma funcionalidade: eles
calculam a taxa de um caixa eletrnico para saques de $20, $50 ou $100, como definido por
amount. A implementao em assembly MIPS a mesma para ambos os fragmentos de cdigo de
alto nvel.
Exemplo de Cdigo 6.18 DECLARAO SWITCH/CASE
switch (amount) { # $s0 = amount, $s1 = fee

case 20: fee = 2; break; case20:
450
case 50: fee = 3; break; addi $t0, $0, 20 # $t0 = 20

case 100: fee = 5; break; bne $s0, $t0, case50 # amount = = 20?Se no,
default: fee = 0; # pular para case50
} addi $s1, $0, 2 # Se sim, fee = 2
j done # e sai do bloco case
// funo equivalente utilizando declaraes
if/else case50:
if (amount = = 20) fee = 2; addi $t0, $0, 50 # $t0 = 50
else if (amount = = 50) fee = 3; bne $s0, $t0, case100 # amount = = 50? Se no
else if (amount = = 100) fee = 5; # pula para case100
else fee = 0; addi $s1, $0, 3 # se sim, fee = 3
case100:
addi $t0, $0, 100 # $t0 = 100
bne $s0, $t0, default # amount = = 100?Se no
# pula para default
addi $s1, $0, 5 # se sim, fee = 5
default:
add $s1, $0, $0 # fee = 0
done:
6.4.4. Entrar em Ciclo

Os ciclos repetidamente executam um bloco de cdigo dependendo de uma condio. Os loops
e loops while so construes de ciclo comuns usadas por linguagens de alto nvel. Esta Seo
mostra como traduzi-las em linguagem assembly MIPS.
451
Loops While
Loops while executam repetidamente um bloco de cdigo at que uma condio seja no
satisfeita. O loop while no Exemplo de Cdigo 6.19 determina o valor de x tal que 2 = 128. Ele
executado sete vezes, at pow = 128.
Assim como declaraes if/else, o cdigo assembly para loops while testa a condio oposta
uma fornecida num cdigo de alto nvel. Se aquela condio TRUE, o loop while terminado.
Exemplo de Cdigo 6.19 LOOP WHILE
Cdigo de Alto nvel Cdigo assembly MIPS
int pow = 1; # $s0 = pow, $s1 = x

int x = 0; addi $s0, $0, 1 # pow = 1
addi $s1, $0, 0 # x = 0
while (pow != 128)
{ addi $t0, $0, 128 # t0 = 128 for
pow = pow * 2; comparison
x = x + 1; while:
} beq $s0, $t0, done # se pow = = 128, sair
while loop
sll $s0, $s0, 1 # pow = pow * 2
addi $s1, $s1, 1 # x = x + 1
j while
done:
No Exemplo de Cdigo 6.19, o loop while compara pow a 128 e sai do loop se existe igualdade.
Caso contrrio, ele dobra pow (utilizando o deslocamento esquerda), incrementa x, e volta para o
incio do loop while.
452
Loops for
Os loops for, assim como loops while, executam repetidamente um bloco de cdigo at que
uma condio no seja aceite. No entanto, os loops for possuem suporte para uma varivel de loop,
que, tipicamente, mantm o controle do nmero de execues do loop. Uma forma geral para o loop
for :
for (initialization; condition; loop operation) Os loops do / while so similares aos loops
while, exceto que eles executam o corpo do
statement
loop uma vez antes de verificar a condio. Eles
O cdigo initialization executado antes do loop for comear. A condition testada so da forma:
no incio de cada loop. Se a condio no verificada, o loop termina. A loop operation do

executada ao final de cada loop. statement
O Exemplo de Cdigo 6.20 adiciona os nmeros de 0 a 9. A varivel de loop, neste caso, i, while (condition);
inicializada com valor 0 e incrementada no final de cada iterao. No incio de cada iterao, o loop
for executado apenas quando i diferente de 10. Caso contrrio, o loop finalizado. Neste caso,
o loop for executado 10 vezes. Os loops for podem ser implementados utilizando-se loops while,
mas o loop for , muitas vezes, mais conveniente.
Comparao de Magnitude
At aqui, os exemplos tm utilizado beq e bne para realizar comparaes de igualdade ou

desigualdade e desvios. A arquitetura MIPS disponibiliza a instruo set less than (a menos de), slt,
para comparao de magnitude. A instruo slt coloca rd a 1 quando rs < rt. Caso contrrio, rd
0.
Exemplo de Cdigo 6.20 LOOP FOR
int sum = 0; # $s0 = i, $s1 = sum

add $s1, $0, $0 # sum = 0
addi $s0, $0, 0 # i = 0
453
for (i = 0; i != 10; i = i + 1) { addi $t0, $0, 10 # $t0 = 10

sum = sum + i ;
} for:
beq $s0, $t0, done # se i == 10, pula para
// equivalent to the following while loop fim
int sum = 0; add $s1, $s1, $s0 # sum = sum + i
int i = 0; addi $s0, $s0, 1 # incrementa i
j for
while (i != 10) { done:
sum = sum + i;
i = i + 1;
}
Exemplo 6.6 LOOPS UTILIZANDO SLT

O cdigo de alto nvel abaixo soma as potncias de 2, de 1 at 100. Traduza-o para linguagem
assembly.
// cdigo de alto nvel
int sum = 0;
for (i = 1; i < 101; i = i * 2)
sum = sum + i;
Soluo O cdigo em linguagem assembly utiliza a instruo slt para realizar a comparao de
menor que no loop for.
# $s0 = i, $s1 = sum
addi $s1, $0, 0 # sum = 0
addi $s0, $0, 1 # i = 1
addi $t0, $0, 101 # $t0 = 101
454
loop:
slt $t1, $s0, $t0 # if (i < 101) $t1 = 1, else $t1 = 0
beq $t1, $0, done # if $t1 == 0 (i >= 101), pula para fim
add $s1, $s1, $s0 # sum = sum + i
sll $s0, $s0, 1 # i = i * 2
j loop
done:
O Exerccio 6.17 explora como utilizar a instruo slt para outras comparaes de magnitude,
incluindo: maior, maior ou igual e menor ou igual.
6.4.5. Arrays
Os arrays so teis para se acessar grandes quantidades de dados similares. Um array organizado
como endereos sequenciais de dados na memria. Cada elemento do array identificado por um
nmero chamado de index. O nmero de elementos de um array chamado dimenso do array. Esta
Seo mostra como acessar elementos de array na memria.
Indexao de Arrays
A Figura 6.20 mostra um array de cinco elementos armazenados na memria. O index varia de 0 a 4.
Nesse caso, o array armazenado na memria principal do processador, comeando do endereo base
010007000. O endereo base corresponde ao endereo do primeiro elemento do array, array[0].
O Exemplo de Cdigo 6.21 multiplica os dois primeiros elementos do array por 8 e os armazena
novamente no array.
455
Figura 6.20 Array de cinco elementos com endereo de base 0x10007000
Exemplo de Cdigo 6.21 ACESSANDO ARRAYS
int array[5]; # $s0 = base address of array

lui $s0, 0x1000 # $s0 = 0x10000000
array[0] = array[0] * 8; ori $s0, $s0, 0x7000 # $s0 = 0x10007000
array[1] = array[1] * 8;
lw $t1, 0($s0) # $t1 = array[0]
sll $t1, $t1, 3 # $t1 = $t1 << 3 = $t1
* 8
sw $t1, 0($s0) # array[0] = $t1
Iw $t1, 4($s0) # $t1 = array[1]

sll $t1, $t1, 3 # $t1 = $t1 << 3 = $t1 * 8
sw $t1, 4($s0) # array[1] = $t1
456
O primeiro passo para o acesso de um elemento de array carregar o endereo base do array
num registrador. O Exemplo de Cdigo 6.21 carrega o endereo base em $s0. Lembre-se que as
instrues lui (carregar imediato superior) e ori (or imediato) podem ser utilizadas para carregar
uma constate de 32 num registrador.
O Exemplo de Cdigo 6.21 tambm ilustra o porqu de lw tomar um endereo de base e um

offset. O endereo de base o ponto de partida do array. Por exemplo, array[1] armazenado
no endereo de memria 010007004 (uma palavra de quatro bytes aps array[0]), ento
acessada por um offset de 4 aps o endereo de base.
O leitor deve ter notado que o cdigo para manipular cada um dos dois elementos de array no
Exemplo de Cdigo 6.21 essencialmente o mesmo, exceto pelo index. Duplicar o cdigo no um
problema quando dois elementos array so acessados, mas isso pode se tornar terrivelmente
ineficiente para acessar todos os elementos num array grande. O Exemplo de Cdigo 6.22 utiliza um
loop for para multiplicar por 8 todos os 1000 elementos de um array armazenado no endereo
base 0238000.
A Figura 6.21 mostra o array de 1000 elementos na memria. O index do array agora uma
varivel (i) ao invs de uma constante, ento, no podemos tirar vantagem do offset imediato em
lw. Ao invs disso, ns computamos o endereo do i-simo elemento e o armazenamos em $t0.
Lembre-se que cada elemento de array uma palavra, mas a memria enderevel por byte, ento
o offset do endereo de base i * 4. Deslocar de 2 para a esquerda um modo conveniente de
multiplicao por 4 na linguagem assembly MIPS. Esse exemplo pode ser estendido prontamente
para um array de qualquer dimenso.
Exemplo de Cdigo 6.22 ACESSANDO ARRAYS UTILIZANDO UM LOOP FOR
int i; # $s0 = enredeo de base do array, $s1 = i

# cdigo de inicializao
int array[1000]; lui $s0, 0x23B8 # $s0 = 0x23B80000
457
for (i = 0; i < 1000; i = i + 1) ori $s0, $s0, 0xF000 # $s0 = 0x23B8F000

array[i] = array[i] * 8; addi $s1, $0, 0 # i = 0
addi $t2, $0, 1000 # $t2 = 1000
loop:
slt $t0, $s1, $t2 # i < 1000?
beq $t0, $0, done # se no, ento fim
sll $t0, $s1, 2 # $t0 = i*4 (byte offset)
add $t0, $t0, $s0 # endereo de array[i]
lw $t1, 0($t0) # $t1 = array[i]
sll $t1, $t1, 3 # $t1 = array[i] * 8
sw $t1, 0($t0) # array[i] = array[i] * 8
addi $s1, $s1, 1 # i = i + 1
j loop # repete
done:
Figura 6.21 Mantendo o elemento array[1000] em memria partindo do endereo base

0x23B8F000
458
Bytes e Caracteres
Os nmeros na faixa de 128 a 127 podem ser armazenados num nico byte ao invs de numa
palavra inteira. Como existem muito menos do que 256 caracteres na lngua inglesa, caracteres ingleses
so frequentemente representados por bytes. A linguagem C utiliza o tipo char para representar um
byte ou caractere.
Os primeiros computadores careciam de um mapeamento padro entre bytes e caracteres da lngua
inglesa, ento trocar textos entre computadores era uma tarefa difcil. Em 1963, a Associao
Americana de Padronizao publicou o Cdigo Padro Americano para o Intercmbio de Informao
(American Standard Code for Information Interchange) ASCII, o qual atribua a cada caractere de texto
um valor nico de byte. A Tabela 6.2 mostra essa codificao de caracteres para caracteres imprimveis.
Os valores ASCII so dados em hexadecimal. Letras em caixa alta e caixa baixa diferem de 0x20 (32).
A linguagem assembly MIPS disponibiliza instrues de carregar byte e armazenar byte, para
manipular bytes ou caracteres de dados: carregar byte sem sinal (load byte unsigned lbu), carregar Outras linguagens de programao, como Java,
byte (load byte lb) e armazenar byte (store byte sb). Todos os trs esto ilustrados na Figura 6.22. usam diferentes codificaes de caracteres,
como o Unicode. O Unicode utiliza 16-bits para
A instruo carregar byte sem sinal (lbu) estende o byte em zeros, e a instruo carregar byte (lb) representar cada caractere, suportando
estende o byte em sinal para completar todo o registrador de 32 . A instruo armazenar byte acentos, tremas, e caracteres asiticos. Para
(sb) armazena o byte menos significativo do registrador de 32 no endereo de memria mais informao, veja www.unicode.org.
especificado pelo byte. Na Figura 6.22, lbu carrega o byte do endereo de memria 2 para o byte menos
significativo de $s1 e completa os bits dos registradores remanescentes com 0. Lb carrega o byte
estendido em sinal no endereo de memria 2 em $s2. sb armazena o byte menos significativo de $s3
na memria do byte 3; isso substitui 07 por 09. Os bytes mais significativos de $s3 so ignorados.
459
Tabela 6.2 Codificao ASCII
O cdigo ASCII foi desenvolvido a partir a

partir de formas anteriores de codificao
de caracteres. A partir de 1838, mquinas
de telgrafo utilizavam o cdigo Morse,
uma srie de pontos e traos, para
representar caracteres. Por exemplo, as
letras A, B, C e D eram representadas como
.-, -..., -.-., e -.., respectivamente. O nmero
de pontos e traos variava com cada letra.
Para eficincia, em cartas comuns eram
utilizados cdigos curtos. Em 1874, Jean-
Maurice Emile Baudot inventou um cdigo
de 5-bits chamado cdigo Baudot. Por
exemplo, A, B, C e D eram representadas
como 00011, 11001, 01110, e 01001. No
entanto, as 32 possveis codificaes desse
cdigo de 5-bits no eram suficientes para
todos os caracteres em ingls. Mas uma
codificao de 8-bits seria. Assim, como a
comunicao eletrnica tornou-se
predominante, a codificao ASCII, de 8-
bits, emergiu como padro.
460
Figura 6.22 Instrues para carregar e armazenar bytes
Exemplo 6.7 UTILIZANDO LB E SB PARA ACESSAR UM ARRAY DE CARACTERES
O cdigo de alto nvel abaixo converte um array de caractere de dez entradas, de letras minsculas
para letras maisculas, atravs da subtrao de 32 a cada entrada do array. Traduza o cdigo em
linguagem assembly MIPS. Lembre-se que a diferena de endereos entre arrays de elementos
agora de 1 byte, no 4 bytes. Assuma que $s0 mantenha o endereo de base para chararray.
// cdigo de alto nvel

char chararray[10];
int i;
for (i = 0; i != 10; i = i + 1)
chararray[i] = chararray[i] 32;
461
Soluo:
# $s0 = endereo de base de chararray, $s1 = i
addi $s1, $0, 0 # i = 0
addi $t0, $0, 10 # $t0 = 10
loop: beq $t0, $s1, done # if i = = 10, sai do loop
add $t1, $s1, $s0 # $t1 = address of
chararray[i]
lb $t2, 0($t1) # $t2 = array[i]
addi $t2, $t2, 32 # converte para caixa alta:
$t2 = $t2 32
sb $t2, 0($t1) # armazena o novo valor em
array:
# chararray[i] = $t2
addi $s1, $s1, 1 # i = i+1
j loop # repete
done:
Figura 6.23 String Hello! Uma serie de caracteres chamada de string. As strings possuem comprimento varivel, logo as
armazenada na memria linguagens de programao devem oferecer um modo de determinar o comprimento ou o fim da
string. Em C, o caractere null (000) significa o fim de uma string. Por exemplo, Figura 6.23
mostra a string Hello! (048 65 6 6 6 21 00) armazenada na memria. A string possui o
comprimento de sete bytes e se estende do endereo 015220 ao 015226. O primeiro
caractere da string (H = 048) armazenado no byte de endereo mais baixo (015220).
462
6.4.6. Chamada de Funes

Linguagens de alto nvel frequentemente utilizam funes (tambm chamadas procedimentos) para
reutilizar cdigos frequentemente acessados e tambm para fazer um programa mais modular e legvel.
As funes possuem entradas, chamadas argumentos, e uma sada, chamada valor de retorno. As
funes calculam o valor de retorno e no causam outros efeitos colaterais indesejveis.
Quando uma funo chama outra, a funo chamadora e a funo chamada devem concordar em
onde colocar os argumentos e os valores de retorno. Em MIPS, a chamadora convencionalmente coloca
at quatro argumentos nos registradores $a0 - $a3 antes de fazer a chamada de funo, e a funo
chamada coloca o valor de retorno em registradores $v0 - $v3 antes do final. Seguindo essa
conveno, ambas as funes sabem onde encontrar os argumentos e o valor de retorno, mesmo se a
chamadora e a chamada foram escritas por diferentes pessoas.
A funo chamada no deve interferir na funo chamadora. De forma breve, isso significa que a
chamada deve saber onde retornar depois de completa, e ela no deve passar por cima de qualquer
registrador ou memria que seja necessrio funo chamadora. A chamadora armazena o endereo
de retorno em $ra, e ao mesmo tempo salta para a funo chamada utilizando a instruo de salto e
conexo (jal). A funo chamada no deve sobrescrever nenhum estado arquitetural ou memria a
qual a funo chamadora dependa. Especificamente, a funo chamada deve deixar os registradores
salvos, $s0 - $s7, $ra e a pilha, uma poro de memria utilizada por variveis temporrias, intacta.
Esta Seo mostra como chamar e retornar valores de uma funo. Ela tambm mostra como as
funes acessam os argumentos de entrada e retornam valores, e como eles utilizam a pilha para
armazenar variveis temporrias.
Chamadas de Funes e Retornos
Em MIPS a instruo salto com conexo (jump and link jal) utilizada para chamar uma funo, e
a instruo salto de registrador (jump register - jr) para retornar de uma funo. O Exemplo de Cdigo
463
6.23 mostra a funo main chamando a funo simple. main a chamadora e simple a
chamada. A funo simple chamada sem argumentos, e no gerado valor de retorno; ela
simplesmente retorna chamadora. No Exemplo de Cdigo 6.23, os endereos de instruo so
dados esquerda de cada instruo MIPS em hexadecimal.
Exemplo de Cdigo 6.23 CHAMADA DE FUNO SIMPLE
int main() { 0x00400200 main: jal simple # chamar funo

simple(); 0x00400204 . . .
. . .
}
// void significa que a funo no retorna
valores
void simple() { 0x00401020 simple: jr $ra # return
return;
}
As instrues salto com conexo (jal) e salto de registrador (jr $ra) so as duas instrues
essenciais necessrias para uma chamada de funo. jal realiza duas operaes: armazena o
endereo da prxima instruo (a instruo aps jal) no registrador de retorno de endereo, e
salta para a funo alvo.
No Exemplo de Cdigo 6.23 , a funo main chama a funo simple atravs da execuo da
instruo salto com conexo (jal). Essa instruo salta para o label simple e armazena
000400204 em $rs. A funo simple retorna imediatamente atravs da execuo da instruo
jr $ra, saltando para o endereo de instruo armazenado em $ra. A funo main ento continua
executando a partir do endereo 000400204.
464
Argumentos de Entrada e Valores de Retorno
A funo simple no Exemplo de Cdigo 6.23 no muito til, pois ela no recebe nenhuma
entrada da funo chamadora (main) e no retorna nenhuma sada. Pela conveno MIPS, funes
utilizam $a0 - $a3 para argumentos de entrada e $v0 - $v1 para o valor de retorno. No
Exemplo de Cdigo 6.24, a funo diffofsums chamada com quatro argumentos e retorna um
resultado.
De acordo com a conveno MIPS, a funo chamadora, main, coloca os argumentos da funo
da esquerda para a direita nos registradores de entrada, $a0 - $a3. A funo chamada,
diffofsums, armazena o valor de retorno no registrador de retorno, $v0.
Uma funo que retorna um valor de 64-bits, tal como um nmero em vrgula flutuante de
preciso dupla (double), utiliza os dois registradores de retorno, $v0 e $v1. Quando uma
funo com mais de quatro argumentos chamada, os argumentos adicionais de entrada so
colocados na pilha, como discutiremos adiante.
Exemplo de Cdigo 6.24 CHAMADA DE FUNO COM ARGUMENTOS E VALORES DE RETORNO
int main() # $s0 = y

{ main:
int y;
. . .
. . . addi $a0, $0, 2 # argumento 0 = 2
addi $a1, $0, 3 # argumento 1 = 3
y = diffofsums(2, 3, 4, 5); addi $a2, $0, 4 # argumento 2 = 4
addi $a3, $0, 5 # argumento 3 = 5
. . . jal diffofsums # chamada de funo
} add $s0, $v0, $0 # y = valor de retorno
int diffofsums(int f, int g, int h, int i) . . .

{ # $s0 = resultado
465
int result; diffofsums:

add $t0, $a0, $a1 # $t0 = f + g
result = (f + g) (h + i); add $t1, $a2, $a3 # $t1 = h + i
return result; sub $s0, $t0, $t1 # resultado=(f + g)(h + i)
} add $v0, $s0, $0 # pe valor de retorno em
$v0
jr $ra # retorna chamadora
A Pilha
A pilha uma memria utilizada para salvar variveis locais dentro de uma funo. A pilha se
expande (utiliza mais memria) conforme o processador precise de mais espao de trabalho, e se
contrai (utiliza menos memria) quando o processador no precisa utilizar mais as variveis l
armazenadas. Antes de explicar como as funes utilizam a pilha para armazenar variveis locais,
explicaremos como a pilha funciona.
A pilha uma fila do tipo ltimo a entrar, primeiro a sair (last-in-first-out LIFO). Assim como uma
pilha de pratos, o ltimo item empurrado (pushed) para a pilha (o prato de cima) o primeiro que
pode ser retirado (popped). Cada funo pode alocar espao na pilha para armazenar variveis locais,
mas deve liberta-lo antes do retorno. O topo da pilha o espao alocado mais recentemente.
Enquanto uma pilha de pratos cresce em espao, a pilha MIPS decresce em memria. A pilha se
expande para os menores endereos de memria quando um programa precisa de mais espao de
trabalho.
A Figura 6.24 mostra uma foto da pilha. O apontador de pilha (stack pointer), $sp, um registrador
MIPS especial que aponta para o topo da pilha. Um apontador um nome ilustrativo para um
endereo de memria. Ele aponta para (dado o endereo) o dado. Por exemplo, na Figura 6.24 (a) o
466
apontador de pilha, $sp, mantm o valor de endereo 07 e aponta para o valor de dado
012345678. $sp aponta para o topo da pilha, a memria mais baixa acessvel na pilha. Assim, na
Figura 6.24 (a), a pilha no pode acessar memrias abaixo da palavra de memria 07.
O apontador de pilha ($sp) parte de um endereo de memria alto e o decrementa, para se

expandir como for necessrio. A Figura 6.24 (b) mostra a expanso de pilha para permitir o
armazenamento temporrio de mais duas palavras de dados. Ao fazer isso, $sp decrementado de
8 para se tornar 074. Duas palavras de dados adicionais, 0 e 011223344,
so temporariamente armazenadas na pilha.
Um dos usos mais importantes da pilha o de salvar e recuperar registradores que esto sendo
utilizados por uma funo. Lembre-se que uma funo deve calcular o valor de retorno, mas no deve
ter nenhum outro efeito colateral no intencional. Em particular, ela no deve modificar nenhum
registrador alm daquele que contm o valor de retorno, %v0. A funo diffofsums no Exemplo
de Cdigo 6.24 viola essa regra, pois modifica $t0, $t1 e $s0. Se a funo main estivesse utilizando
$t0, $t1 ou $s0 antes da chamada de diffofsums, o contedo desses registradores seria
corrompido pela chamada de funo.
Para resolver esse problema, uma funo salva os registradores na pilha antes de os modificar, e
logo os recupera da pilha antes de retornar os valores. Especificamente, ela realiza os seguintes
passos:
1. Abre espao na pilha para armazenar os valores de um ou mais registradores;
2. Armazena os valores dos registradores na pilha;
3. Executa as funes utilizando os registradores;
4. Recupera os valores originais dos registradores na pilha;
5. Liberta o espao na pilha. Figura 6.24 A pilha
467
Figura 6.25 A pilha (a) antes, (b) depois e (c) aps a chamada da funo diffofsums
O Exemplo de Cdigo 6.25 mostra uma verso melhorada de diffofsums, que salva e recupera
$t0, $t1 e $s0. As novas linhas so indicadas em azul. A Figura 6.25 mostra a pilha antes, durante
e depois da chamada da funo diffofsums do Exemplo de Cdigo 6.25. diffofsums abre
espao para trs palavras na pilha decrementando o apontador de pilha $sp em 12. Ela ento
armazena os valores atuais de $s0, $t0 e $t1 no novo espao alocado. Ela executa o resto da
funo, mudando os valores nesses trs registradores. Ao final da funo, diffofsums recupera
os valores de $s0, $t0 e $t1, e $sp possui os mesmos valores que tinha antes da chamada de
funo.
O espao de pilha que uma funo aloca por si s chamado quadro de pilha (stack frame). A
stack frame de diffofsums contm trs palavras. O princpio da modularidade diz que cada
funo deve acessar apenas a seu prprio stack frame, e no as frames pertencentes a outras
funes.
Exemplo de Cdigo 6.25 FUNO SALVANDO REGISTRADORES NA PILHA
Cdigo assembly MIPS
# $s0 = result
diffofsums:
468
addi $sp, $sp, 12 # abre espao na pilha para armazenar trs registradores
sw $s0, 8($sp) # salva $s0 na pilha
sw $t0, 4($sp) # salva $t0 na pilha
sw $t1, 0($sp) # salva $t1 na pilha
add $t0, $a0, $a1 # $t0 = f + g
add $t1, $a2, $a3 # $t1 = h + i
sub $s0, $t0, $t1 # result = (f + g) (h + i)
add $v0, $s0, $0 # pe o valor de retorno em $v0
lw $t1, 0($sp) # recupera $t1 da pilha
lw $t0, 4($sp) # recupera $t0 da pilha
lw $s0, 8($sp) # recupera $s0 da pilha
addi $sp, $sp, 12 # liberta espao na pilha
Registradores Preservados
O Exemplo de Cdigo 6.25 assume que registradores temporrios $t0 e $t1 devem ser salvos
e recuperados. Se as funes chamadoras no utilizarem esses registradores, o esforo para salv-
los e recuper-los desperdiado. Para evitar esse desperdcio, o MIPS divide os registradores nas
categorias preservado e no preservado. Os registradores preservados incluem $s0 - $s7 (da
seus nomes, salvos). Os registradores no preservados incluem $t0 - $t9 (da seus nomes,
temporrios). Uma funo deve salvar e recuperar qualquer um dos registradores preservados
que ela deseje usar, mas pode mudar os registradores no preservados livremente.
O Exemplo de Cdigo 6.26 mostra uma verso ainda mais melhorada de diffofsums, que
salva apenas $s0 na pilha. $t0 e $t1 so registradores no preservados, ento no necessrio
que sejam salvos.
469
Lembre-se que quando uma funo chama outra, a ltima a chamadora e a nova a chamada.
A chamada deve salvar e recuperar qualquer registrador preservado que deseje utilizar. A chamada
pode mudar qualquer registrador no preservado. Consequentemente, se a chamadora est
mantendo dados ativos num registrador no preservado, a chamadora precisa salvar aquele
registrador no preservado antes de fazer a chamada de funo, e ento precisa recuper-lo
posteriormente. Por essas razes, registradores preservados so tambm chamados callee-saved,
e registradores no preservados so chamados caller-saved.
Exemplo de Cdigo 6.26 FUNO SALVANDO REGISTRADORES PRESERVADOS NA PILHA
Cdigo assembly MIPS
# $s0 = result
diffofsums
addi $sp, $sp, 4 # abre espao na pilha para armazenar um registrador
sw $s0, 0($sp) # salva $s0 na pilha
add $t0, $a0, $a1 # $t0 = f + g
add $t1, $a2, $a3 # $t1 = h + i
sub $s0, $t0, $t1 # result = (f + g) (h + i)
add $v0, $s0, $0 # pe o valor de retorno em $v0
lw $s0, 0($sp) # recupera $s0 da pilha
addi $sp, $sp, 4 # liberta espao da pilha
A Tabela 6.3 resume quais os registradores preservados. $s0 - $s7 so geralmente utilizados
para manter os valores de variveis locais dentro de uma funo, ento eles devem ser salvos. $ra
tambm deve ser salvo, de modo que a funo saiba onde retornar. $t0 - $t9 so utilizados
para manter os resultados temporrios antes de eles serem atribudos como variveis locais. Estes
clculos so tipicamente completados antes que uma chamada de funo seja feita, logo no so
preservados, e raramente e funo chamadora precisa salv-los. $a0 - $a3 so frequentemente
470
sobrescritos no processo de chamada de funo. Consequentemente, eles devem ser salvos por uma
funo chamadora, se a mesma depender de algum de seus prprios argumentos aps o retorno da
funo chamada. $v0 - $v1 certamente no deveriam ser preservados, pois a funo chamada
retorna seus resultados nesses registradores.
A pilha acima do apontador de pilha automaticamente preservada, desde que a funo
chamadora no escreva em endereos de memria acima de $sp. Desse modo, ela no modifica o
stack frame de nenhuma outra funo. O apontador de pilha em si preservado, pois a funo
chamada liberta o seu stack frame antes do retorno atravs da adio da mesma quantidade que foi
subtrada de $sp no incio da funo.
Tabela 6.3 Registradores preservados e no preservados
Chamadas Recursivas de Funo

Uma funo que no chama outras chamada funo folha (leaf); um exemplo a funo
diffofsums. Uma funo que chama outras chamada funo nonleaf. Como mencionado
anteriormente, funes nonleaf so, de certo modo, mais complicadas, pois elas podem precisar
salvar registradores no preservados na pilha antes de chamarem outra funo, e em seguida
recuperar esses valores posteriormente. Especificamente, a funo chamadora salva qualquer
registador no preservado ($t0 - $t9 e $a0 - $a3) que for utilizado aps a chamada. A funo
chamada salva qualquer um dos registradores preservados ($s0 - $s7 e $ra) que tiver
pretenso de modificar.
471
Uma funo recursiva uma funo nonleaf que se chama a si mesma. A funo fatorial pode ser
escrita como uma chamada de funo recursiva. Lembre-se que () = ( 1)
( 2) 2 1. A funo fatorial pode ser reescrita recursivamente como () =
( 1). O fatorial de 1 simplesmente 1. O Exemplo de Cdigo 6.27 mostra a funo
fatorial escrita como uma funo recursiva. Para atribuir corretamente os endereos de programas,
assumimos que o programa tem incio no endereo 090.
A funo fatorial modifica $a0 e $ra, e por isso salva-os na pilha. Ela ento verifica se n < 2.
Se sim, coloca o valor de retorno 1 em $v0, restaura o apontador de pilha, e retorna para a funo
chamadora. Ela no tem que recarregar $ra e $a0 nesse caso, pois eles nunca foram modificados.
Se n > 1, a funo recursivamente chama a factorial(n-1). Ela ento, recupera o valor de n
($a0) e o endereo de retorno ($ra) da pilha, realiza a multiplicao, e retorna o resultado. A
instruo de multiplicao (mul $v0, $a0, $v0) multiplica $a0 e $v0 e coloca o resultado em
$v0.
Exemplo de Cdigo 6.27 Chamada de funo recursiva fatorial
int factorial(int n) { 0x90 factorial: addi $sp, $sp, 8 # abreespao

na pilha
0x94 sw $a0, 4($sp) # guarda $a0
0x98 sw $ra, 0($sp) # guarda $ra
0x9C addi $t0, $0, 2 # $t0 = 2
if (n <= 1) OxAO slt $t0, $a0, $t0 # n <= 1 ?
return 1; 0xA4 beq $t0, $0, else # no: goto
else
0xA8 addi $v0, $0, 1 # sim: return
1
OxAC addi $sp, $sp, 8 # recupera
$sp
OxBO jr $ra # return
472
0xB4 else: addi $a0, $a0, 1 # n = n 1

else 0xB8 jal factorial # chamada
return (n * factorial(n 1)); recursiva
} OxBC Iw $ra, 0($sp) # recupera
$ra
OxCO Iw $a0, 4($sp) # recupera
$a0
0xC4 addi $sp, $sp, 8 # recupera
$sp
0xC8 mul $v0, $a0, $v0 # n *
factorial(n1)
OxCC jr $ra # return
A Figura 6.26 mostra a pilha quando executada a funo fatorial(3). Assumimos que $sp
inicialmente aponta para 0, como mostrado na Figura 6.26 (a). A funo cria uma stack frame
de duas palavras para manter $a0 e $ra. Na primeira invocao, fatorial salva $a0 (mantendo
n = 3) em 08 e $ra em 04, como mostrado na Figura 6.26 (b). A funo ento muda $a0 para
n = 2, e recursivamente chama fatorial(2), fazendo com que $ra mantenha 0. Na segunda
invocao, ela salva $a0 (mantendo n =2) em 00 e $ra em 0. Dessa vez, ns sabemos que
$ra contm 0. A funo ento muda $a0 para n = 1 e recursivamente chama fatorial(1).
Na terceira invocao, ela salva $a0 (mantendo n = 1) em 08 e $ra em 04. Dessa vez, $ra
novamente contm 0. A terceira invocao de fatorial retorna o valor 1 em $v0 e liberta a
stack frame antes de retornar segunda invocao. A segunda invocao restaura n para 2, restaura
$ra para 0 (aconteceu de j estar com este valor), liberta a stack frame, e devolve $v0 =
2 1 = 2 para a primeira invocao. A primeira invocao restaura n para 3, $ra para o endereo
de retorno da funo chamadora, liberta a stack frame, e retorna $v0 = 3 2 = 6. A Figura 6.26 (c)
mostra a pilha como um retorno de funo chamada recursivamente. Quando fatorial retorna
473
funo chamadora, o apontador de pilha est na sua posio original (0), nenhum dos
contedos da pilha acima do apontador mudou, e todos os registradores preservados mantm seus
valores originais. $v0 mantm o valor de retorno, 6.
Figura 6.26 Pilha durante a chamada da funo factorial quando n = 3: (a) antes de
chamada, (b) aps a ltima chamada recursiva, (c) aps o retorno
Argumentos Adicionais e Variveis Locais*
As funes podem ter mais de quatro argumentos de entrada e variveis locais. A pilha
utilizada para armazenar estes valores temporrios. Pela conveno MIPS, se uma funo possui
mais de quatro argumentos, os primeiros quatro so transmitidos para registradores de argumento
como normalmente. Os argumentos adicionais so transmitidos para a pilha, logo acima de $sp.
A funo chamadora deve expandir a sua pilha para abrir espao para os argumentos adicionais. A
Figura 6.27 (a) mostra a pilha da funo chamadora para quando ela possui mais do que quatro
argumentos.
474
Uma funo tambm pode declarar variveis locais ou arrays. Variveis locais so declaradas dentro
de uma funo e podem ser acessadas apenas dentro daquela funo. As variveis locais so
armazenadas em $s0 - $s7. Se existem muitas variveis locais, elas podem ser armazenadas no
stack frame da funo. Em particular, arrays locais so armazenados na pilha.
A Figura 6.27 (b) mostra a organizao de uma stack frame da funo chamada. A stack frame
mantm os prprios argumentos das funes, e retorna os endereos, e qualquer um dos registradores
salvos que a funo ir modificar. Isso tambm mantm os valores dos arrays locais e quaisquer
variveis locais adicionais. Se a funo chamada possui mais de quatro argumentos, ela os encontra na
stack frame da funo chamadora. O acesso a argumentos de entradas adicionais uma exceo na
qual uma funo pode acessar os dados da pilha fora da sua prpria stack frame.
Figura 6.27 Uso de pilha: (a) antes da chamada, (b) aps a chamada
475
6.5. MODOS DE ENDEREAMENTO

O MIPS utiliza cinco modos de endereamento: register-only, imediato, base, relativo ao PC e
pseudo-direto. Os primeiros trs mtodos (register-only, imediato e endereamento de base)
definem modos de leitura e de escrita de operandos. Os ltimos dois (relativo ao PC e
endereamento pseudo-direto) definem modos de escrita no contador de programa, o PC.
Endereamento Register-Only
O endereamento register-only utiliza registradores para todos os operandos fonte e destino.
Todas as instrues tipo-R utilizam endereamento register-only.
Endereamento Imediato
O endereamento imediato utiliza os 16 do imediato, juntamente com os registradores
como operandos. Algumas instrues tipo-I, como adicionar imediato (addi) e carregar imediato
superior (lui), utilizam endereamento imediato.
Endereamento de Base
Instrues de acesso memria, como carregar palavra (lw) e armazenar palavra (sw), utilizam
endereamento de base. O endereo efetivo do operando de memria encontrado adicionando-
se o endereo de base no registrador com o offset de 16 , estendido em sinal, encontrado no
campo do imediato.
Endereamento Relativo ao PC
Instrues de branch condicional utilizam endereamento relativo ao PC para especificar um novo
valor para o PC se o desvio realizado. O offset com sinal no campo do imediato adicionado ao PC
para obter um novo PC; consequentemente, o endereo de destino do branch dito como sendo
relativo ao PC atual.
476
O Exemplo de Cdigo 6.28 mostra parte da funo factorial do Exemplo de Cdigo 6.27. A
Figura 6.28 mostra o cdigo de mquina para a instruo beq. O endereo de destino do branch
(branch target address - BTA) o endereo da prxima instruo a ser executada caso o desvio seja
efectuado. A instruo beq na Figura 6.28 possui o BTA de 04, o endereo de instruo do label
else.
O campo de imediato de 16 d o nmero de instrues entre o BTA e a instruo aps a
instruo de branch (a instruo em + 4). Nesse caso, o valor do campo intermedirio de beq
3, pois o BTA (04) est 3 instrues aps + 4 (08).
O processador calcula o BTA a partir da instruo fazendo uma extenso de 16 do sinal do
imediato, multiplicando-o por 4 (para converter as palavras em bytes), e adicionando-o a + 4.
Exemplo de Cdigo 6.28 CALCULANDO O ENDEREO DESTINO DO BRANCH
Cdigo assembly MIPS
0xA4 beq $t0, $0, else

0xA8 addi $v0, $0, 1
0xAC addi $sp, $sp, 8
0xBO jr $ra
0xB4 else: addi $a0, $a0, 1
0xB8 jal factorial
Figura 6.28 Cdigo de mquina para beq
477
Exemplo 6.8 CALCULANDO O CAMPO DE IMEDIATO PARA O ENDEREAMENTO RELATIVO AO PC

Calcule o campo de imediato e mostre o cdigo de mquina para a instruo branch no igual
(bne) no programa abaixo.
# MIPS assembly code
0x40 loop: add $t1, $a0, $s0
0x44 lb $t1, 0($t1)
0x48 add $t2, $a1, $s0
0x4C sb $t1, 0($t2)
0x50 addi $s0, $s0, 1
0x54 bne $t1, $0, loop
0x58 lw $s0, 0($sp)
Soluo: A Figura 6.29 mostra o cdigo de mquina para a instruo bne. Seu endereo destino de
branch, 040, est 6 instrues atrs de + 4 (058), ento o campo de imediato 6.
Figura 6.29 Cdigo de mquina para bne
Endereamento Pseudo-direto
No endereamento direto, um endereo especificado na instruo. Os saltos de instrues, j

e jal, deveriam, idealmente, utilizar endereamento direto para especificar um endereo alvo de
salto (jump target address JTA) para indicar o endereo de instruo a ser executado em seguida.
Infelizmente, a codificao de instrues do tipo-J no possui bits suficientes para especificar um
JTA de 32-bits. Seis bits de instruo so utilizados pelo opcode, ento, apenas 26-bits so deixados
478
para codificar o JTA. Felizmente, os dois bits menos significativos, JTA1:0, deve sempre ser 0, pois as
instrues so alinhadas em palavra. Os prximos 26-bits, JTA27:2, so tomados do campo addr da
instruo. Os quatro bits mais significativos, JTA31:28, so obtidos dos quatro bits mais significativos de
+ 4. Esse modo de endereamento chamado pseudo-direto.
Exemplo de Cdigo 6.29 CALCULANDO O ENDEREO DESTINO DO JUMP
Cdigo assembly MIPS
0x0040005C jal sum

...
0x004000A0 sum: add $v0, $a0, $a1
O Exemplo de Cdigo 6.29 ilustra a instruo jal utilizando o endereamento pseudo-direto.

O JTA da instruo jal 00040000. A Figura 6.30 mostra o cdigo de mquina para a instruo
jal. Os quatro bits superiores e dois bits inferiores do JTA so descartados. Os bits remanescentes
so armazenados no campo de endereo de 26-bits (addr).
O processador calcula o JTA a partir da instruo tipo-J acrescentando dois 0 no final e os dois
bits mais significativos de + 4 no incio do campo de endereos de 26-bits (addr).
Devido aos quatro bits mais significativos do JTA serem tomados de + 4, a amplitude do
salto limitada. A faixa limite do branch e as instrues de salto so exploradas do Exerccio 6.29
ao Exerccio 6.32 . Todos as instrues do tipo-J, j e jal, utilizam endereamento pseudo-direto.
Note que a instruo de salto de registrador, jr, no uma instruo tipo-J. uma instruo
tipo-R que salta para o valor de 32-bits mantido no registrador rs.
479
Figura 6.30 Cdigo de mquina para jal
6.6. LUZ, CMERA, AO: COMPILANDO, MONTANDO E

CARREGANDO
At agora, temos mostrado como traduzir fragmentos curtos de cdigo de alto nvel em linguagem
de mquina e assembly. Esta Seo descreve como compilar e montar um programa de alto nvel
completo e como carregar o programa na memria para a execuo.
Comearemos introduzindo o mapa de memria MIPS, que define onde cdigos, dados e pilha so
localizados. Em seguida mostraremos os passos para a execuo de cdigo para um programa de
exemplo.
6.6.1. O Mapa de Memria
Com endereos de 32-bits o espao de endereos MIPS alcana 232 bytes = 4 Gigabytes (GB). Os
endereos de palavras so divisveis por 4 e vo de 0 a 0. A Figura 6.31 mostra o mapa de
memria MIPS. A arquitetura MIPS divide o espao de endereos em quatro partes, ou segmentos: o
segmento de texto, o segmento de dados globais, o segmento de dados dinmicos e o segmento
reservado. As seguintes sees descrevem cada segmento.
480
O Segmento de Texto
O segmento de texto armazena o programa em linguagem de mquina. Ele grande o suficiente
para acomodar quase 256 MB de cdigo. Note que os quatros bits mais significativos de endereo no
espao de texto so todos 0, logo a instruo j pode saltar diretamente para qualquer endereo no
programa.
Figura 6.31 Mapa de memria MIPS
O Segmento de Dados Globais

O segmento de dados globais armazena variveis globais que, em contraste com as variveis locais,
podem ser vistas por todas as funes num programa. Variveis globais so definidas pelo start-up,
481
antes do programa comear a ser executado. Essas variveis so declaradas fora da funo principal
num programa em C, e podem ser acessadas por qualquer funo. O segmento de dados globais
grande o suficiente para armazenar 64 kB de variveis globais.
As variveis globais so acessadas utilizando-se o ponteiro global ($gp), o qual inicializado em

000080000. Ao contrrio do ponteiro de pilha ($sp), o $gp no muda durante a execuo do
programa. Qualquer varivel global pode ser acessada com um offset de 16-bits, positivo ou negativo,
em $gp. O offset conhecido no momento de assemblagem, ento as variveis podem ser
eficientemente acessadas utilizando o modo de endereamento de base com offsets constantes.
O Segmento de Dados Dinmicos
O segmento de dados dinmicos mantm a pilha e o heap (monte). O dado nesse segmento no
conhecido no start-up, mas dinamicamente alocado e libertado durante a execuo do programa.
Grace Hopper, 1906 - 1992 Este o maior segmento de memria utilizado por um programa, contendo quase 2 GB de espao de
Graduada pela Universidade de Yale endereos.
com Ph.D em matemtica. Desenvolveu Como discutido na Seo 6.4.6, a pilha utilizada para salvar e recuperar registradores utilizados
o primeiro compilador enquanto por funes, e para manter variveis locais, como arrays. A pilha cresce de cima para baixo no
trabalhava na Remington Rand segmento de dados dinmicos (07), e cada stack frame acessada na ordem LIFO (ltimo
Corporation, e foi fundamental no a entrar, primeiro a sair).
desenvolvimento da linguagem de O heap armazena dados que so alocados pelo programa durante o seu tempo de execuo. Em
programao COBOL. Como oficial C, as alocaes so feitas pela funo malloc; em C++ e Java, a funo new utilizada na alocao
naval, recebeu muitos prmios, de memria. Do mesmo modo que um amontoado de sapatos no cho da sala de um alojamento, os
inclusive uma Medalha de Vitria da dados do heap podem ser utilizados e descartados em qualquer ordem. O heap cresce de baixo para
Segunda Guerra Mundial e a Medalha cima no segmento de dados dinmicos.
de Servio Defesa Nacional.
Se a pilha e o heap sempre crescem, os dados do programa podem ser corrompidos. O alocador
de memria tenta se certificar de que isso nunca acontea, retornando um erro de memria se houver
espao insuficiente para alocar mais dados dinmicos.
482
Os Segmentos Reservados
Os segmentos reservados so utilizados pelo sistema operacional e no podem ser utilizados
diretamente pelo programa. Parte da memria reservada utilizada para interrupes (veja
Seo 7.7) e para I/O de memria mapeada (veja Seo 8.5).
6.6.2. Traduzindo e Iniciando um Programa
A Figura 6.32 mostra os passos necessrios para se traduzir um programa de uma linguagem de
alto nvel em linguagem de mquina, e para iniciar a execuo desse programa. Primeiramente, o
cdigo de alto nvel compilado para cdigo assembly. O cdigo assembly montado em
linguagem de mquina num arquivo objeto. O linker combina o cdigo de mquina com o cdigo
objeto das bibliotecas e outros arquivos para produzir um programa inteiramente executvel. Na
prtica, a maioria dos compiladores realizam todos os trs passos de compilar, montar e linkar.
Finalmente, o loader carrega o programa na memria e inicia a execuo. O restante desta Seo
realiza esses trs passos para um programa simples.
Passo 1: Compilao
Um compilador traduz o cdigo de alto nvel em linguagem assembly. O Exemplo de Cdigo 6.30 Figura 6.32 Passos para traduzir e
mostra um programa simples em linguagem de alto nvel com trs variveis globais e duas funes, rodar um programa
juntamente com o cdigo assembly produzido por um compilador tpico. As expresses .data e
.text so diretivas que indicam onde os textos e os segmentos de dados iniciam. As labels so
utilizadas para as variveis globais f, g e y. Seus locais de armazenamento sero determinados
pelo assembler; por agora, eles so deixados como smbolos no cdigo.
Exemplo de Cdigo 6.30 COMPILANDO UM PROGRAMA DE ALTO NVEL
int f, g, y; // global variables .data

f:
g:
y:
483
int main(void) .text

{ main:
f = 2; addi $sp, $sp, 4 # faz stack frame
g = 3; sw $ra, 0($sp) # guarda $ra na pilha
y = sum(f, g); addi $a0, $0, 2 # $a0 = 2
return y; sw $a0, f # f = 2
} addi $a1, $0, 3 # $a1 = 3
sw $a1, g # g = 3
jal sum # chama funo sum
sw $v0, y # y = sum(f, g)
Iw $ra, 0($sp) # recupera $ra da pilha
addi $sp, $sp, 4 # recupera apontador de
pilha
jr $ra # retorna ao SO
int sum(int a, int b) {
return (a + b); sum:
} add $v0, $a0, $a1 # $v0 = a + b
jr $ra # returna chamadora
Passo 2: Montagem
O assembler transforma o cdigo em linguagem assembly num arquivo objeto contendo cdigo
de linguagem de mquina. O assembler faz duas passagens para o cdigo assembly. Na primeira
passagem, o assembler atribui os endereos de instrues e encontra todos os smbolos, como labels
e nomes de variveis globais. O cdigo aps a primeira passagem do assembler mostrado aqui.
0x00400000 main: addi $sp, $sp, 4
0x00400004 sw $ra, 0($sp)
0x00400008 addi $a0, $0, 2
0x0040000C sw $a0, f
0x00400010 addi $a1, $0, 3
0x00400014 sw $a1, g
484
0x00400018 jal sum

0x0040001C sw $v0, y
0x00400020 lw $ra, 0($sp)
0x00400024 addi $sp, $sp, 4
0x00400028 jr $ra
0x0040002C sum: add $v0, $a0, $a1
0x00400030 jr $ra
Os nomes e endereos dos smbolos so mantidos numa tabela de smbolos, como mostrado na
Tabela 6.4, para esse cdigo. Os endereos dos smbolos so preenchidos aps a primeira passagem,
quando os endereos das labels so conhecidos. Variveis globais so atribudas em locais de
armazenamento no segmento de dados globais da memria, partindo do endereo 010000000.
Na segunda passagem pelo cdigo, o assembler produz o cdigo de linguagem de mquina. Os
endereos para as variveis globais e labels so tomados da tabela de smbolos. O cdigo em linguagem
de mquina e a tabela de smbolos so armazenados no arquivo objeto.
Tabela 6.4 Tabela de smbolos
Passo 3: Ligando
A maioria dos programas grandes contm mais de um arquivo. Se o programador muda apenas um
dos arquivos, seria desperdcio recompilar e remontar os outros arquivos. Em particular, programas
frequentemente chamam funes em arquivos de bibliotecas; esses arquivos de bibliotecas quase
485
nunca mudam. Se um arquivo de cdigo de alto nvel no alterado, o arquivo objeto associado
a ele no precisa ser atualizado.
O trabalho do linker combinar todos os arquivos objetos num arquivo de linguagem de
mquina denominado executvel. O linker realoca os dados e as instrues nos arquivos objetos
de modo que eles no fiquem uns sobre os outros. Ele utiliza as informaes na tabela de smbolos
para ajustar os endereos das variveis globais e dos labels que foram realocados.
No nosso exemplo, existe apenas um arquivo objeto, ento nenhuma realocao necessria.
A Figura 6.33 mostra o arquivo executvel. Ele possui trs sees: O cabealho (header), o
segmento de texto e o segmento de dados. O header do arquivo executvel informa o tamanho
do texto (tamanho do cdigo) e o tamanho do dado (quantidade de dados declarados
globalmente). Ambos so dados em unidades de bytes. O segmento de texto d as instrues para
que eles sejam armazenados na memria.
A figura mostra as instrues num formato legvel prximo ao cdigo de mquina para
facilidade de interpretao, mas o arquivo executvel inclui apenas instrues de mquina. O
segmento de dados d o endereo de cada varivel global. As variveis globais so endereadas
com respeito ao endereo de base dado pelo ponteiro globa, $gp. Por exemplo, a primeira
instruo de armazenamento, sw $a0, 0x8000($gp) armazena o valor na varivel global f,
que est localizada no endereo de memria 0x10000000. Lembre-se que o offset, 08000, um
nmero de 16-bits com sinal, que estendido em sinal e somado ao endereo de base, $gp.
Ento, $gp + 08000 = 010008000 + 08000 = 010000000, o endereo de memria
da varivel f.
486
Figura 6.33 Executvel
Passo 4: Carregando
O sistema operacional carrega um programa lendo o segmento de texto de um arquivo executvel
a partir de um dispositivo de armazenamento (geralmente um disco rgido) para o prximo segmento
de memria. O sistema operacional carrega em $gp o valor 010008000 (a metade do segmento
de dados globais) e em $sp o valor 07 (o topo do segmento de dados dinmicos), e, em
seguida, executa a instruo jal 000400000 para saltar para o incio do programa. A Figura 6.34
mostra o mapa de memria no incio da execuo do programa.
487
Figura 6.34 Executvel carregado na memria
488
6.7. MISCELNEA
Esta Seo cobre alguns tpicos opcionais que no se encaixam naturalmente em outros lugares do
Captulo. Esses tpicos incluem pseudo-instrues, excees, instrues aritmticas com sinal e sem
sinal, e instrues de vrgula flutuante.
6.7.1. Pseudo-instrues
Se uma instruo no est disponvel no conjunto de instrues MIPS, porque, provavelmente, a
mesma operao pode ser realizada utilizando uma ou mais instrues MIPS existentes. Lembre-se que
o MIPS um computador de conjunto reduzido de instrues (RISC - reduced instruction set computer),
onde o tamanho das instrues e a complexidade de hardware so minimizados mantendo-se o nmero
de instrues pequeno.
No entanto, o MIPS define pseudo-instrues que no so verdadeiramente parte do conjunto de
instrues, mas so comumente utilizados por programadores e compiladores. Quando convertidos em
cdigo de mquina, as pseudo-instrues so traduzidas numa ou mais instrues MIPS.
A Tabela 6.5 d exemplos de pseudo-instrues e as instrues MIPS utilizadas para implement-los.
Por exemplo, a pseudo-instruo carregar imediato (li) carrega uma constante de 32-bits usando uma
combinao das instrues lui e ori. A pseudo-instruo de no operao (nop, pronunciada no
op) no realiza operaes. O PC incrementado em 4 na sua execuo. Nenhum outro valor de
registrador ou memria alterado. O cdigo de mquina para a instruo nop 000000000.
Algumas pseudo-instrues requerem um registrador temporrio para clculos intermedirios. Por
exemplo, a pseudo-instruo beq $t2, imm15:0, compara em Loop $t2 a um imediato de 16-bits
imm15:0. Esta pseudo-instruo requer um registrador temporrio para armazenar o imediato de 16-
bits. Os assemblers utilizam o registrador assembler, $at, para tais propsitos. A Tabela 6.6 mostra
como o assembler usa $at na converso de uma pseudo-instruo para instrues MIPS reais.
Deixamos isso como os Exerccio 6.38 e Exerccio 6.39, para o leitor implementar outras pseudo-
instrues, como rodar esquerda (rol) e rodar direita (ror).
489
Tabela 6.5 Pseudo-instrues
Tabela 6.6 Pseudo-instrues utilizando $at
6.7.2. Excees
Uma exceo como uma chamada de funo sem marcao, que salta para um novo endereo.
Excees podem ser causadas por hardware ou software. Por exemplo, o processador pode
receber notificaes de que o usurio pressionou uma tecla no teclado. O processador pode parar
o que est fazendo, determinar qual tecla pressionada, salv-la para uma futura referncia, e ento
voltar ao programa que estava sendo executado. Uma exceo de hardware, disparada por um
dispositivo de entrada/sada (Input/Output I/O) tal como um teclado frequentemente chamada
de interrupo. Alternativamente, o programa pode encontrar uma condio de erro, como uma
instruo indefinida. O programa ento salta para o cdigo no sistema operacional (OS), que pode
490
escolher encerrar o programa problemtico. Excees de software so, s vezes, chamadas traps.
Outras causas de exceo incluem diviso por zero, tentativa de leitura de memria inexistente, mal
funcionamento de hardware, interrupes do depurador e overflow aritmtico (ver Seo 6.7.3).
O processador grava a causa de uma exceo e o valor do PC no momento em que a exceo
ocorre. Ele ento salta para a funo de tratamento de exceo. A funo de tratamento de exceo
um cdigo (usualmente do sistema operacional) que examina a causa da exceo e responde
apropriadamente (lendo o teclado numa interrupo de hardware, por exemplo). Ela ento retorna
ao programa que estava executando antes da exceo aparecer. No MIPS, a funo de tratamento
de exceo est sempre localizada em 080000180. Quando uma exceo ocorre, o processador
sempre salta para esse endereo de instruo, independentemente da causa.
Tabela 6.7 Cdigos de causa de excees
A arquitetura MIPS utiliza um registrador de propsito especial, chamado registrador cause,

para gravar a causa da exceo. Cdigos diferentes so utilizados para gravar diferentes causas de
exceo, como mostrado na Tabela 6.7. O cdigo de tratamento de exceo l o registrador cause
para determinar como tratar a exceo. Algumas outras arquiteturas saltam para uma funo de
tratamento de excees diferente para cada causa diferente, ao invs de utilizar um registrador
cause.
491
O MIPS utiliza outro registrador de propsito especial denominado Contador de programa de

exceo (Exception Program Counter EPC) para armazenar o valor do PC no momento em que a
exceo acontece. O processador retorna ao endereo em EPC aps tratar a exceo. Isso
anlogo a utilizar $ra para armazenar o valor antigo do PC numa instruo jal.
Os registradores EPC e cause no so parte do banco de registradores MIPS. A instruo mfc0

(mover do coprocessador 0) copia estes e outros registradores de propsito especial para os
registradores de propsito geral. O Coprocessador 0 chamado de controle do processador MIPS;
ele trata as interrupes e o diagnstico do processador. Por exemplo, mfc0 $t0, cause copia
o registrador cause para $t0.
As instrues syscall e break causam traps para realizar chamadas de sistema ou pontos
de interrupo do depurador. A funo de tratamento de excees utiliza o EPC para procurar a
instruo e determinar a natureza da chamada de funo ou ponto de interrupo, procurando
nos campos da instruo.
Em resumo, uma exceo faz com que o processador salte para a funo de tratamento de
excees. A funo de tratamento de excees salva os registradores na pilha, em seguida utiliza
mfc0 para procurar a causa e responder de acordo. Quando o tratamento terminado, ela
recupera os registradores da pilha, copia os endereos de retorno de EPC para $k0, e retorna
utilizando jr $k0.
6.7.3. Instrues com Sinal e sem Sinal
0 e $k1 so includos no conjunto de Lembre-se que um nmero binrio pode ser com sinal ou sem sinal. A arquitetura MIPS utiliza
registradores MIPS. Eles so reservados pelo SO a representao em complemento-2 para nmeros com sinal. O MIPS possui certas instrues que
para tratamento de excees. Eles no vm na variante sinalizados e sem sinals, incluindo adio e subtrao, multiplicao e diviso,
precisam ser salvos e recuperados durante as
ativar menor que, e carregar palavras parcialmente.
excees.
Adio e Subtrao
A adio e a subtrao so realizadas identicamente se o nmero possui ou no sinal. No
entanto, a interpretao dos resultados diferente.
492
Como mencionado na Seo 1.4.6, se dois nmeros grandes com sinal so adicionados, o
resultado pode, incorretamente, produzir o sinal oposto. Por exemplo, somar os nmeros
positivos abaixo resulta num resultado negativo: 07 + 07 =
0 = 2. Similarmente, somar dois nmeros grandes e negativos resulta num
nmero positivo: 080000001 + 080000001 = 000000002. Isso chamado de overflow
aritmtico.
A linguagem C ignora os overflows aritmticos, mas outras linguagens, como Fortran, requerem
que o programa seja notificado. Como mencionado na Seo 6.7.2, o processador MIPS pe uma
exceo num overflow aritmtico. O programa pode decidir o que fazer a respeito do overflow
(por exemplo, repetir o clculo com nmeros de maior preciso), ento retornar de onde o
programa foi parado.
O MIPS fornece verses com e sem sinal de adio e subtrao. As verses com sinal so add,
addi e sub. As verses sem sinal so addu, addiu, e subu. As duas verses so idnticas,
exceto que nas verses com sinal disparam uma exceo de overflow, enquanto nas verses sem
sinal no disparam. Como o C ignora excees, programas em C tecnicamente utilizam as verses
sinalizadas dessas instrues.
Multiplicao e Diviso
Multiplicao e diviso se comportam de modo diferente para nmeros com sinal e sem sinal.
Por exemplo, com um nmero sem sinal, 0 representa um nmero grande, mas um
nmero com sinal representa 1. Consequentemente, 0 X 0 seria igual
a 000000001 se os nmeros fossem sem sinal, mas igual a 00000000000000001
se os nmeros tivessem sinal.
Portanto, a multiplicao e a diviso esto disponveis em ambas as variantes, com e sem sinal.
mult e div tratam os operados como nmeros sinalizados. multu e divu tratam os operandos
como nmeros sem sinal.
493
Ativar Menor que
Instrues ativar menor que podem comparar tanto dois registradores (slt) ou um registrador
e um imediato (slti). Ela tambm vem em verses para nmeros com sinal (slt e slti) e sem
sinal (sltu e sltiu). Numa comparao, 080000000 menor do que qualquer outro nmero,
pois o maior nmero negativo em complemento-2. Numa comparao sem sinal, 080000000
maior que 07, mas menor que 080000001, pois todos os nmeros so positivos.
Tome cuidado, pois sltiu estende em sinal o imediato antes de trata-lo como um nmero sem
sinal. Por exemplo, sltiu $s0, $s1, 0x8042 compara $s1 a 08042, tratando o
imediato como um grande nmero positivo.
Carregamentos
Como descrito na Seo 6.4.5, o carregamento de bytes est disponvel nas verses com sinal
(lb) e sem sinal (lbu). A funo lb estende o byte em sinal, e lby estende em zeros o byte para
completar inteiramente o registrador de 32-bits. Similarmente, o MIPS fornece instrues de
carregamento de meias palavras sem e com sinal (lh e lhu), que carregam dois bytes na metade
inferior da palavra, e a estende em sinal ou zero metade superior.
6.7.4. Instrues em Vrgula Flutuante
A arquitetura MIPS define um coprocessador opcional de vrgula flutuante, conhecido como
coprocessador. Nas primeiras implementaes MIPS, o coprocessador de vrgula flutuante era um
chip separado que os usurios poderiam comprar, caso necessitassem de operaes matemticas
rpidas em vrgula flutuante. Nas implementaes MIPS mais recentes, o coprocessador de vrgula
flutuante construdo bem ao lado do processador principal.
O MIPS define trinta e dois registradores de 32-bits de vrgula flutuante, $f0 - $f31. Esses
registradores so separados dos registradores normais utilizados at agora. O MIPS suporta tanto
a aritmtica IEEE de vrgula flutuante de preciso simples quanto a de preciso dupla. Nmeros com
494
preciso dupla (64-bits) so armazenados em pares de registradores de 32-bits e, ento, apenas os

16 registradores pares ($f0, $f2, $f4, ..., $f30) so utilizados para especificar operaes com
preciso dupla. Por conveno, certos registradores so reservados para certos propsitos, como
fornecido na Tabela 6.8.
Figura 6.35 Formato de instruo de mquina Tipo-F
Tabela 6.8 Conjunto de instrues MIPS vrgula flutuante
Instrues em vrgula flutuante possuem um opcode de 17 (100012 ). Elas necessitam tanto de

um campo funct quanto de um campo cop (coprocessador) para indicar o tipo de instruo.
Consequentemente, a MIPS define o formato de instruo tipo-F para instrues de vrgula flutuante,
mostrado na Figura 6.35. Instrues em vrgula flutuante esto disponveis tanto com preciso
simples quanto com preciso dupla. Para instrues de preciso simples cop = 16 (100002 ) ou
495
17 (100012 ) para instrues de preciso dupla. Assim como as instrues do tipo-R, instrues
do tipo-F possuem dois operandos fonte, fs e ft, e um destino, fd.
A preciso da instruo indicado por .s e .d no mnemnico. Instrues de aritmtica de

vrgula flutuante incluem adio (add.s, add.d), subtrao (sub.s, sub.d), multiplicao
(mul.s, mul.d), e diviso (div.s, div.d), assim como negao (neg.s, neg.d) e valor
absoluto (abs.s, abs.d).
O branch em vrgula flutuante possui duas partes. Primeiro, uma instruo de comparao
utilizada para ativar ou limpar a flag de condio de vrgula flutuante (fpcond). Em seguida, um
branch condicional verifica o valor da flag. As instrues de comparao incluem igualdade
(c.seq.s/c.seq.d), menor que (c.lt.s/c.lt.d), e menor ou igual (c.le.s/c.le.d).
As instrues de branch condicional so bc1f e bc1t, que desviam se fpcond FALSE ou TRUE,
respectivamente. As comparaes de desigualdade, maior que, maior ou igual, so realizadas com
seq, lt e le, seguidas por bc1f.
Registradores de vrgula flutuante so carregados e armazenados na memria utilizando lwc1

e swc1. Essas instrues movem 32-bits, logo duas instrues so necessrias para manipular um
nmero de preciso dupla.
6.8. PERSPECTIVA DO MUNDO REAL: ARQUITETURA X86

Quase todos os computadores pessoais hoje em dia utilizam microprocessadores com
arquitetura 86. A arquitetura 86, tambm chamada de IA-32, uma arquitetura de 32-bits
originalmente desenvolvida pela Intel. A AMD tambm vende microprocessadores compatveis
com 86.
A arquitetura 86 tem uma longa e complicada historia datando do ano de 1978, quando a
Intel anunciou o microprocessador de 16-bits 8086, e seu primo, o 8088, para o primeiro
computador pessoal, feito pela IBM. Em 1985, a Intel introduziu o microprocessador de 32-bits
80386, que era compatvel com o 8086, e ento podia rodar softwares desenvolvidos para PC
496
anteriores. Processadores com arquiteturas compatveis com o 80386 so chamados processadores

86. O Pentium, Core e Athlon so alguns processadores 86 bem conhecidos. A Seo 7.9 descreve
a evoluo dos microprocessadores com mais detalhes.
Vrios grupos da Intel e da AMD, atravs de muitos anos, foram encaixando mais instrues e
capacidades na antiquada arquitetura. O resultado muito menos elegante que o MIPS. Como
Patterson e Hennessy explicam, essa linhagem ancestral levou a uma arquitetura que difcil de
explicar e impossvel de amar. No entanto, a compatibilidade de software mais importante que a
elegncia tcnica, ento a 86 tem sido, de fato, a arquitetura padro de PC h mais de duas dcadas.
Mais de 100 milhes de processadores 86 so vendidos todo ano. Esse grande mercado justifica os
mais de $5 bilhes em pesquisa e desenvolvimento que, anualmente, continuam melhorando os
processadores.
Tabela 6.9 Principais diferenas entre as arquiteturas MIPS e x86
A arquitetura 86 um exemplo de um Computador com arquitetura CISC - Conjunto de Instrues

Complexo (Complex Instruction Set Computer). Em contraste com as arquiteturas RISC, como MIPS,
cada instruo CISC pode fazer mais. Programas para arquiteturas CISC usualmente requerem menos Figura 6.36 Registro do x86
instrues. As codificaes de instrues foram selecionadas para serem mais compactas, de modo a
497
poupar memria, quando a RAM era bem mais cara do que hoje; as instrues possuem
comprimento varivel e frequentemente tm menos de 32-bits. Em compensao, as instrues
complicadas so mais difceis de decodificar e tendem a ser executadas mais lentamente.
Esta Seo introduz a arquitetura 86. O objetivo no transformar o leitor num programador
de linguagem assembly x86, mas apenas ilustrar algumas das similaridades e diferenas entre 86
e MIPS. Pensamos que interessante ver como um 86 funciona. No entanto, nenhum dos
materiais nesta Seo necessrio para entender o resto do livro. As principais diferenas entre
86 e MIPS so resumidas na Tabela 6.9.
6.8.1. Registradores x86
O microprocessador 8086 fornecia oito registradores de 16-bits, o que podia separadamente
acessar os oito bis superiores e inferiores de alguns desses registradores. Quando o 80386 foi
introduzido, os registradores foram estendidos para 32-bits. Esses registradores eram chamados
EAX, ECX, EDX, EBX, ESP, EBP, ESI e EDI. Para compatibilidade com verses anteriores, os 16-
bits inferiores e algumas pores de 8-bits so tambm utilizveis, como mostrado na Figura 6.36.
Os oito registradores so quase, mas no muito, de propsito geral. Certas instrues no podem
utilizar certos registradores. Outras instrues sempre colocam seus resultados em certos
registradores. Assim como $sp em MIPS, ESP normalmente reservado para o apontador de pilha.
O contador de programa da 86 chamado EIP (extended instruction pointer apontador de
instruo estendido). Assim como o PC do MIPS, ele avana de uma instruo a outra, e pode ser
mudado com branch, saltos, e instrues de chamadas de funo.
6.8.2. Operandos x86
Instrues MIPS sempre operam em registradores ou imediatos. Instrues explcitas de
carregamento e armazenamento so necessrias para mover dados entre a memria e os
registradores. Em contraste, instrues 86 podem operar em registradores, imediatos ou
memria. Isto compensa parcialidade o pequeno conjunto de registradores.
498
Tabela 6.10 Localizao de operandos
Tabela 6.11 Modos de endereamento de memria
As instrues MIPS geralmente especificam trs operandos: duas fontes e um destino. Instrues
86 especificam apenas dois operandos. O primeiro a fonte. O segundo tanto uma fonte quanto
um destino. Consequentemente, instrues 86 sempre sobrescrevem uma de suas fontes com o
resultado. A Tabela 6.10 lista as combinaes de localizaes de operandos em 86. Todas as
combinaes so possveis, exceto memria para memria.
Assim como MIPS, 86 possui um espao de memria de 32-bits que enderevel por byte. No
entanto, 86 tambm suporta uma variedade muito grande de modos de endereamento de
499
memria. Os locais de memria so especificados com qualquer combinao de um registrador de

base, deslocamento, e um registrador de ndice escalado. A Tabela 6.11 ilustra essas combinaes.
O deslocamento pode ser um valor de 8-, 16- ou 32-bits. A escala multiplicando o ndice do
registrador pode ser 1, 2, 4 ou 8. A base + modo de desvio so equivalentes ao modo de
endereamento de base no MIPS para carregamentos e armazenamentos. O ndice deslocado
fornece um modo simples para acessar arrays de estruturas de elementos de 2-, 4- ou 8-bytes, sem
ter que emitir uma sequncia de instrues para gerar o endereo.
Enquanto o MIPS sempre opera em palavras de 32-bits, as instrues da 86 podem operar em
dados de 8-, 16- ou 32-bits. A Tabela 6.12 ilustra essas variaes.
Tabela 6.12 Instrues sobre dados de 8- 16- ou 32-bits
6.8.3. Flags de Status

A 86, assim como muitas arquiteturas CISC, utiliza flags de status (tambm chamadas cdigos
de condio) para tomar decises a respeito de branches e para manter o controle dos transbordos
e de overflow aritmtico. A 86 utiliza um registrador de 32-bits chamado EFLAGS, que armazena
as flags de status. Alguns dos bits do registrador EFLAGS so dados na Tabela 6.13. Outros bits so
utilizados pelo sistema operacional.
O estado arquitetural de um processador 86 inclui a EFLAGS, assim como os oito registradores

e o EIP.
500
6.8.4. Instrues x86

A arquitetura 86 possui um conjunto de instrues maior do que a MIPS. A Tabela 6.14 descreve
algumas instrues de propsito geral. A 86 tambm tem instrues para aritmtica de vrgula
flutuante e para aritmtica de mltiplos elementos de dados compactados numa palavra maior. D
indica o destino (um registro ou localizao de memria), e S indica a fonte (um registrador, localizao
de memria, ou imediato).
Tabela 6.13 EFLAGS selecionadas
501
Tabela 6.14 Instrues selecionadas x86
502
Tabela 6.15 Condies de branch selecionadas
Note que algumas instrues sempre operam sobre registradores especficos. Por exemplo, uma
multiplicao de 32 por 32-bits sempre toma uma das fontes de EAX, e sempre coloca o resultado
de 64-bits em EDX e EAX. LOOP sempre armazena o contador de loop em ECX. PUSH, POP, CALL
e RET utilizam o apontador de pilha, ESP.
Saltos condicionais verificam as flags e desviam se a condio apropriada atingida. Eles esto
disponveis em diferentes formas. Por exemplo, JZ salta se a flag de zero (ZF) 1. JNZ salta se a flag
de zero 0. O salto usualmente segue uma instruo, como a instruo de comparao (CMP), que
seta as flags. A Tabela 6.15 lista alguns dos saltos condicionais, e como eles dependem da ativao
de uma flag por uma operao de comparao.
503
Figura 6.37 Instrues de codificao x86
6.8.5. Codificao de Instrues x86

As codificaes de instrues 86 so realmente confusas, um legado de dcadas de
mudanas fragmentadas. Ao contrrio da MIPS, na qual as instrues possuem uniformemente
32-bits, as instrues 86 variam de 1 a 15 bytes, como mostrado na Figura 6.37. O opcode pode
ser de 1, 2 ou 3 bytes, e seguido por quatro campos opcionais: Mod R/M, SIB,
Displacement e Immediate. Mod R/M especifica um modo de endereamento. SIB
especifica a escala, index e registradores de base em certos modos de endereamento.
Displacement indica um deslocamento de 1-, 2- ou 4 bytes em certos modos de
endereamento. E Immediate uma constante de 1-, 2- ou 4-bytes, para instrues que
utilizam um imediato como operando fonte. Mais ainda, uma instruo pode ser precedida por
at quatro prefixos opcionais em bytes tipo long, que modificam o seu comportamento.
O byte Mod R/M usa o campo de 2-bits Mod e o de 3-bits R/M para especificar o modo de
endereamento para um dos operandos. O operando pode vir de um dos oito registradores, ou
de um dos 24 modos de endereamento. Devido aos artefatos nas codificaes, os registradores
ESP e EBP no esto disponveis para uso como registradores de base ou index em certos modos
504
de endereamento. O campo Reg especifica o registrador usado como outro operando. Para certas
instrues que no requerem um segundo operando, o campo Reg utilizado para especificar mais
trs bytes do opcode.
Em modos de endereamento que utilizam um registrador de ndice escalado, o byte SIB

especifica o registrador de index e a escala (1, 2, 4 ou 8). Se tanto a base quanto o index so
utilizados, o byte SIB tambm especifica o registrador de base.
A MIPS especifica totalmente a instruo no opcode e no campo funct da instruo. A

arquitetura 86 utiliza um nmero varivel de bits para especificar diferentes instrues. Ela utiliza
menos bits para especificar instrues mais comuns, decrementando o comprimento mdio das
instrues. Algumas instrues ainda possuem mltiplos opcodes. Por exemplo, add AL, imm8
realiza uma soma de 8-bits entre um imediato e AL. Isso representado pelo opcode de 1-byte,
004, seguido por um imediato de 1-byte. O registrador A (AL, AX ou EAX) chamado de
acumulador. Por outro lado, add D, imm8 realizam uma soma de 8-bits entre um imediato e um
destino arbitrrio, D (memria ou registrador). representado pelo opcode de 1-byte, 080,
seguido por um ou mais bytes especificando D, seguido por um imediato de 1 byte. Muitas instrues
possuem codificaes reduzidas quando o destino o acumulador.
No 8086 original, o opcode especificava se a instruo atuava sobre operandos de 8- ou 16-bits.

Quando o 80386 introduziu os operandos de 32-bits, no existiam novos opcodes disponveis para
especificar a forma de 32-bits. Ao invs disso, o mesmo opcode foi utilizado por ambas as formas de
16-bits e 32-bits. Um bit adicional no descritor de segmento de cdigo utilizado pelos Sistemas
Operacionais especificava qual a forma que o processador deveria escolher. O bit colocado a 0
para compatibilidade com verses anteriores com programas do 8086, padronizando o opcode para
operandos de 16-bits. Ele colocado a 1 para programas com operandos com padro de 32-bits.
Mais ainda, o programador pode especificar prefixos para mudar a forma de uma instruo
particular. Se o prefix 066 aparece antes do opcode, o tamanho alternativo de operando
utilizado (16-bits em modo de 32-bits, ou 32-bits em modo de 16-bits).
505
6.8.6. Outras Peculiaridades da x86

O 80826 introduziu segmentaes para dividir a memria em segmentos de at 64 kB de
comprimento. Quando o SO ativa a segmentao, os endereos so computados relativamente ao incio
do segmento. O processador verifica para endereos que vo alm do fim do segmento e indica um erro,
prevenindo assim, os programas de acessarem memria fora de seu prprio segmento. A segmentao
provou ser um incmodo para os programadores, e no utilizada em verses modernas dos sistemas
operacionais Windows.
A x86 contm instrues de strings que operam em strings inteiras de bytes ou palavras. As operaes
incluem o movimento, comparao e o varrimento para a procura de um valor especfico. Nos
processadores modernos, estas instrues so normalmente mais lentas do que realizar a operao
equivalente com uma srie de instrues mais simples, ento melhor evita-las.
Como mencionado anteriormente, o prefixo 066 utilizado para escolher entre tamanhos de
operandos de 16- e 32-bits. Outros prefixos incluem aqueles utilizados para bloquear o barramento (para
controlar o acesso a variveis compartilhadas num sistema multiprocessador), para prever se um branch
vai ou no ser realizadp, e para repetir a instruo durante um movimento de string.
A runa de qualquer arquitetura rodar fora de sua capacidade de memria. Com endereos de 32-
bits, a 86 pode acessar 4 GB de memria. Isso era bem mais do que os maiores computadores possuam
em 1985, mas no incio dos anos 2000 ela se tornou limitada. Em 2003, a AMD estendeu o espao de
endereos e o tamanho dos registradores para 64 bits, chamando a arquitetura melhorada de AMD64. A
AMD64 possui um modo de compatibilidade que permite rodar programas de 32-bits no modificados,
enquanto o SO toma vantagem do maior espao de endereos. Em 2004, a Intel cedeu e adotou as
extenses de 64 bits, as renomeou para Extended Memory 64 Technology (EM64T). Com endereos de
64 bits, os computadores podem acessar 16-exabytes (16 milhes de GB) de memria.
Para aqueles curiosos a respeito de mais detalhes da arquitetura 86, o Manual do Desenvolvedor de
Software em Arquitetura Intel 86 est disponvel gratuitamente no website da Intel.
506
6.8.7. A Big Picture Intel e HP conjuntamente desenvolveram uma

Esta Seo tem dado uma ideia de algumas das diferenas entre a arquitetura RISC MIPS e a nova arquitetura de 64 bits chamada IA-64, em
arquitetura CISC 86. A 86 tende a ter programas mais curtos, pois uma instruo complexa meados de 1990. Ela foi projetada baseada em
equivalente a uma srie de instrues MIPS simples e porque as instrues so codificadas para um desenho limpo, ignorando a complicada
minimizar o uso de memria. No entanto, a arquitetura 86 uma mistura de caractersticas histria da x86, tirando vantagem de 20 anos de
pesquisa em arquitetura de computadores, e
acumuladas ao longo dos anos, algumas das quais no so mais teis, mas devem ser mantidas para a
fornecendo um espao de endereamento de
compatibilidade com programas antigos. Ela tem bem menos registradores, e as instrues so difceis 64 bits. No entanto, a IA-64 ainda tem o que
de decodificar. Mesmo explicar o conjunto de instrues difcil. Apesar de todas essas imperfeies, fazer para se tornar um sucesso comercial. A
a 86 est firmemente enraizada como a arquitetura dominante de PC, pois o valor da compatibilidade maioria dos computadores que necessita de
de software muito grande e porque o grande mercado justifica o esforo requerido em construir grandes espaos de endereamento utilizam
microprocessadores 86 rpidos. extenses da arquitetura x86.
6.9. SUMRIO
Para comandar um computador, voc deve falar sua linguagem. Uma arquitetura de computador
define como comandar o processador. Muitas arquiteturas diferentes de computadores esto
difundidas comercialmente hoje em dia, mas uma vez que o leitor entenda uma delas, aprender outras
muito mais fcil. As questes chave a serem perguntadas quando nos aproximamos de uma nova
arquitetura so:
Qual o comprimento das palavras de dados?
Quais so os registradores?
Como a memria organizada?
Quais so as instrues?
A MIPS uma arquitetura de 32-bits pois opera em dados de 32-bits. A arquitetura MIPS possui 32
registradores de propsito geral. No entanto, por conveno, alguns registradores so reservados para
certos propsitos, para facilitar a programao, de modo que funes escritas por diferentes
programadores possam se comunicar facilmente. Por exemplo, o registrador 0 ($0) sempre mantm
a constante 0, $ra mantm o endereo de retorno aps uma instruo jal, e $a0 - $a3 e $v0 -
507
$v1 mantm os argumentos e valores de retorno de uma funo. A MIPS possui um sistema de
memria enderevel por byte com endereos de 32-bits. O mapa de memria foi descrito na
Seo 6.6.1. As instrues possuem 32-bits e devem ser alinhadas por palavra. Este Captulo
discutiu as instrues MIPS mais comumente utilizadas.
O poder de definir uma arquitetura de computador que um programa escrito para qualquer
dada arquitetura pode rodar em muitas diferentes implementaes dessa arquitetura. Por
exemplo, programas escritos para o processador Intel Pentium em 1993 iro, geralmente,
continuar rodando (e muito mais rpido) no Intel Xeon ou no AMD Phenom, processadores de
2012.
Na primeira parte deste livro, o leitor aprendeu sobre os circuitos nveis lgicos de abstrao.
Neste Captulo, saltamos para o nvel da arquitetura. No prximo Captulo, estudaremos a
microarquitetura, o arranjo de blocos digitais que implementam a arquitetura de um processador.
A microarquitetura a ligao entre a engenharia de hardware e de software. E mais, acreditamos
que ele um dos tpicos mais excitantes em toda a engenharia: o leitor ir aprender a construir
seu prprio microprocessador!
508
Exerccios
Exerccio 6.1 D trs exemplos, na arquitetura MIPS, de cada um dos princpios de projeto de
arquitetura: (1) simplicidade favorece regularidade; (2) fazer o caso comum rpido; (3) menor mais
rpido; e (4) bons projetos demandam bons compromissos. Explique como cada um dos seus
exemplos exibe esses princpios.
Exerccio 6.2 A arquitetura MIPS possui um conjunto de registradores que consiste em

registradores de 32-bits. possvel projetar uma arquitetura computacional sem um conjunto de
registradores? Se sim, descreva brevemente a arquitetura, incluindo o conjunto de instrues. Quais
so as vantagens e desvantagens dessa arquitetura sobre a arquitetura MIPS?
Exerccio 6.3 Considere o armazenamento, em memria, de uma palavra de 32-bits, armazenada

na palavra de memria 42 numa memria enderevel por byte.
(a) Qual o byte de endereo da palavra de memria 42?
(b) Qual o byte de endereo que a palavra de memria 42 alcana?
(c) Represente o nmero 0223344 armazenado na palavra 42 em mquinas big endian e little
endian. A sua representao deve ser similar da Figura 6.4. Claramente rotule o byte de endereo
correspondente a cada valor de byte de dados.
Exerccio 6.4 Repita o Exerccio 6.3 para um armazenamento de memria de uma palavra de 32-
bits armazenada na palavra de memria 15 numa memria enderevel por byte.
509
Exerccio 6.5 Explique como o programa abaixo pode ser utilizado para determinar se um
computador big endian ou little endian.
li $t0, 0xABCD9876
sw $t0, 100($0)
lb $s5, 101($0)
Exerccio 6.6 Escreva as seguintes strings utilizando codificao ASCII. Escreva sua resposta final
em hexadecimal.
(a) SOS
(b) Cool!
(c) Seu prprio nome
Exerccio 6.7 Repita o Exerccio 6.6 para as seguintes strings

(a) howdy
(b) lions
(c) To the rescue!
Exerccio 6.8 Mostre como as strings no Exerccio 6.6 so armazenadas numa memria
enderevel por byte em (a) uma mquina big endian e (b) uma mquina little endian partindo do
endereo de memria 010000100. Utilize um diagrama de memria similar Figura 6.4.
Indique claramente o endereo de memria de cada byte em cada mquina.
Exerccio 6.9 Repita o Exerccio 6.8 para as strings do Exerccio 6.7.

510
Exerccio 6.10 Converta o seguinte cdigo assembly MIPS em linguagem de mquina. Escreva as
instrues em hexadecimal.
add $t0, $s0, $s1
lw $t0, 0x20($t7)
addi $s0, $0, 10
Exerccio 6.11 Repita o Exerccio 6.10 para o seguinte cdigo assembly MIPS:
addi $s0, $0, 73
sw $t1, 7($t2)
sub $t1, $s7, $s2
Exerccio 6.12 Considere instrues tipo-I.

(a) Quais instrues do Exerccio 6.10 so do tipo-I?
(b) Estenda em sinal o imediato de 16-bits de cada instruo da parte (a) de modo que se torne um
nmero de 32-bits.
Exerccio 6.13 Repita o Exerccio 6.12 para as instrues no Exerccio 6.11.
Exerccio 6.14 Converta o seguinte programa de linguagem de mquina para linguagem assembly
MIPS. Os nmeros esquerda so endereos de instruo na memria, e os nmeros direita do a
instruo naquele endereo. Ento utilize engenharia reversa num programa de alto nvel que
compilaria isso numa rotina de linguagem assembly e o escreva. Explique em palavras como esse
programa funciona. $a0 a entrada, e ela inicialmente contm um nmero positivo, n. $v0 a sada.
511
0x00400000 0x20080000
0x00400004 0x20090001
0x00400008 0x0089502A
0x0040000C 0x15400003
0x00400010 0x01094020
0x00400014 0x21290002
0x00400018 0x08100002
0x0040001C 0x01001020
0x00400020 0x03E00008
Exerccio 6.15 Repita o Exerccio 6.14 para o cdigo de mquina abaixo. $a0 e $a1 so
entradas. $a0 contm um nmero de 32 bits e $a1 o endereo de um array de 32 elementos
de caracteres (char).
0x00400000 0x2008001F
0x00400004 0x01044806
0x00400008 0x31290001
0x0040000C 0x0009482A
0x00400010 0xA0A90000
0x00400014 0x20A50001
0x00400018 0x2108FFFF
0x0040001C 0x0501FFF9
0x00400020 0x03E00008
Exerccio 6.16 A instruo nori no faz parte do conjunto de instrues MIPS, pois a mesma
funcionalidade pode ser implementada utilizando funes existentes. Escreva um pequeno
fragmento de cdigo assembly que tenha a seguinte funcionalidade: $t0 = $t1 NOR 0xF234.
Utiliza o mnimo de instrues possvel.
512
Exerccio 6.17 Implemente o seguinte segmento de cdigo de alto nvel utilizando a instruo
slt. Assuma as variveis inteiras g e h como sendo os registradores $s0 e $s1,
respectivamente.
(a) if (g > h)
g = g + h;
else
g = g h;
(b) if (g >= h)
g = g + 1;
else
h = h 1;
(c) if (g <= h)
g = 0;
else
h = 0;
Exerccio 6.18 Escreva uma funo numa linguagem de alto nvel para int find42(int
array[], int size). O nmero de elementos em array especificado por size, e
array especifica os endereos de base do array. A funo deve retornar o index da primeira
entrada do array que mantenha o valor 42. Caso nenhuma entrada do array seja 42, o valor
retornado deve ser 1.
Exerccio 6.19 A funo de alto nvel strcpy copia a string de caracteres src para a string
de caracteres dst.
// cdigo em C
void strcpy(char dst[], char src[]) {
int i = 0;
513
do {
dst[i] = src[i];
} while (src[i++]);
}
(a) Implemente a funo strcpy em cdigo assembly MIPS. Utilize $s0 para i.
(b) Desenhe uma imagem da pilha antes, durante e depois da chamada da funo strcpy.
Assuma que $sp = 0x7FFFF00 antes de strcpy ser chamada.
Exerccio 6.20 Converta a funo de alto nvel do Exerccio 6.18 em cdigo assembly MIPS.
Exerccio 6.21 Considere o cdigo assembly MIPS dado abaixo. func1, func2 e func3 so
funes nonleaf. A func4 uma funo leaf. O cdigo no mostrado para cada funo, mas os
comentrios indicam quais registradores utilizados em cada funo.
0x00401000 func1 : . . . # func1 uses $s0$s1
0x00401020 jal func2
. . .
0x00401100 func2: . . . # func2 uses $s2$s7
0x0040117C jal func3
. . .
0x00401400 func3: . . . # func3 uses $s1$s3
0x00401704 jal func4
. . .
0x00403008 func4: . . . # func4 uses no preserved
0x00403118 jr $ra # registers
(a) Quantas palavras tm as stack frames de cada funo?
514
(b) Esboce a pilha depois que func4 chamada. Indique claramente onde cada registrador
armazenado na pilha, e marque cada uma das stack frames. D os valores onde for possvel.
Exerccio 6.22 Cada nmero na srie de Fibonacci a soma dos dois nmeros anteriores. A Tabela
6.16 lista os primeiros nmeros na srie fib(n).
Tabela 6.16 Srie de Fibonacci
(a) Qual o valor de fib(n) para n = 0 e n = -1?
(b) Escreva uma funo chamada fib numa linguagem de alto nvel que retorna o nmero de
Fibonacci para qualquer valor no negativo de n. Dica: Voc provavelmente vai querer usar um loop.
Comente claramente o seu cdigo.
(c) Converta a funo de alto nvel de (b) em cdigo assembly MIPS. Adicione comentrios aps
cada linha de cdigo, que expliquem claramente o que elas fazem. Utilize o simulador SPIM para
testar o seu cdigo em fib(9) (Veja no prefcio como instalar o simulador SPIM).
Exerccio 6.23 Considere o cdigo C do Exemplo 6.27. Para esse exerccio, assuma que fatorial
chamada com um argumento de entrada n = 5.
(a) Qual o valor em $v0 quando fatorial retorna funo chamadora?

(b) Suponha que o leitor apaga as instrues dos endereos 098 e 0, que salvam e
recuperam $ra. O programa (1) entrar num loop infinito, mas no travar; (2) Travar (pois faz
com que a pilha cresa alm do segmento de dados dinmicos ou do PC, saltando para uma
515
localizao fora do programa); (3) produz um valor incorreto em $v0 quando o programa retorna para
o loop (se sim, qual o valor?), ou (4) roda corretamente, apesar das linhas apagadas?
(c) Repita a parte (b) quando as instrues nos seguintes endereos de instruo so apagadas:
(i) 094 e 00 (instrues que salvam e recuperam $a0)
(ii) 090 e 04 (instrues que salvam e recuperam $sp). Nota: a label fatorial no apagada
(iii) 0 (uma instruo que recupera $sp)
Exerccio 6.24 Bem Bitdiddle est tentando computar a funo (, ) = 2 + 3 para um b no

negativo. Ele passou dos limites no uso das chamadas de funes e recurses, e produziu o seguinte
cdigo de alto nvel para funes f e f2:
// cdigos de alto nvel para as funes f e f2
int f(int a, int b) {
int j;
j = a;
return j + a + f2(b);
}
int f2(int x)
{
int k;
k = 3;
if (x == 0) return 0;
else return k + f2(x l);
}
Ben ento, traduziu as duas funes em linguagem assembly, como se segue. Ele tambm escreveu
uma funo, test, que chama a funo f(5.3).
516
0x00400000 test: addi $a0, $0, 5 # $a0 = 5 (a = 5)

0x00400004 addi $a1, $0, 3 # $a1 = 3 (b = 3)
0x00400008 jal f # call f(5, 3)
0x0040000C loop: j loop # and loop forever
0x00400010 f: addi $sp, $sp, 16 # make room on the stack
# for $s0, $a0, $a1, and $ra
0x00400014 sw $a1, 12($sp) # save $a1 (b)
0x00400018 sw $a0, 8($sp) # save $a0 (a)
0x0040001C sw $ra, 4($sp) # save $ra
0x00400020 sw $s0, 0($sp) # save $s0
0x00400024 add $s0, $a0, $0 # $s0 = $a0 (j = a)
0x00400028 add $a0, $a1, $0 # place b as argument for f2
0x0040002C jal f2 # call f2(b)
0x00400030 lw $a0, 8($sp) # restore $a0 (a) after call
0x00400034 lw $a1, 12($sp) # restore $a1 (b) after call
0x00400038 add $v0, $v0, $s0 # $v0 = f2(b) + j
0x0040003C add $v0, $v0, $a0 # $v0 = (f2(b) + j) + a
0x00400040 lw $s0, 0($sp) # restore $s0
0x00400044 lw $ra, 4($sp) # restore $ra
0x00400048 addi $sp, $sp, 16 # restore $sp (stack pointer)
0x0040004C jr $ra # return to point of call
0x00400050 f2: addi $sp, $sp, 12 # make room on the stack for
# $s0, $a0, and $ra
0x00400054 sw $a0, 8($sp) # save $a0 (x)
0x00400058 sw $ra, 4($sp) # save return address
0x0040005C sw $s0, 0($sp) # save $s0
0x00400060 addi $s0, $0, 3 # k = 3
0x00400064 bne $a0, $0, else # x = 0?
0x00400068 addi $v0, $0, 0 # yes: return value should be 0
0x0040006C j done # and clean up
0x00400070 else: addi $a0, $a0, 1 # no: $a0 = $a0 1 (x = x 1)
0x00400074 jal f2 # call f2(x 1)
517
0x00400078 lw $a0, 8($sp) # restore $a0 (x)

0x0040007C add $v0, $v0, $s0 # $v0 = f2(x 1) + k
0x00400080 done: lw $s0, 0($sp) # restore $s0
0x00400084 lw $ra, 4($sp) # restore $ra
0x00400088 addi $sp, $sp, 12 # restore $sp
0x0040008C jr $ra # return to point of call
O leitor provavelmente achar interessante fazer desenhos da pilha, similares quele da Figura
6.26, para ajuda-lo a responder as seguintes questes.
(a) Se o cdigo roda partindo de test, qual valor est em $v0 quando o programa chega a loop?
O programa computa corretamente a expresso 2 + 3?
(b) Suponha que Ben apaga as instrues nos endereos 00040001 e 000400044, que
salvam e recuperam $ra. O programa ir (1) entrar num loop infinito mas no trava; (2) trava (faz
com que a pilha cresa alm do segmentos de dados dinmicos ou o PC salta para uma localizao
fora do programa); (3) produz um valor incorreto em $v0 quando o programa retorna do loop (se
sim, qual valor?), ou (4) roda corretamente apesar das linhas apagadas?
(c) Repita a parte (b) quando as instrues nos endereos de instruo seguintes so apagadas.
Note que as labels no foram apagadas, apenas as instrues.
i) 0x00400018 e 0x00400030 (instrues que salvam e recuperam $a0)
ii) 0x00400014 and 0x00400034 (instrues que salvam e recuperam $a1)

iii) 0x00400020 and 0x00400040 (instrues que salvam e recuperam
$s0)
iv) 0x00400050 and 0x00400088 (instrues que salvam e recuperam $sp)
v) 0x0040005C and 0x00400080 (instrues que salvam e recuperam $s0)
vi) 0x00400058 and 0x00400084 (instrues que salvam e recuperam $ra)
518
vii) 0x00400054 and 0x00400078 (instrues que salvam e recuperam

$a0)
Exerccio 6.25 Converta as seguintes instrues assembly beq, j e jal, em cdigo de mquina. Os
enderees das instrues so dados esquerda de cada instruo.
(a)
0x00401000 beq $t0, $s1, Loop
0x00401004 . . .
0x00401008 . . .
0x0040100C Loop: . . .
(b)
0x00401000 beq $t7, $s4, done
. . . . . .
0x00402040 done: . . .
(c)
0x0040310C back: . . .
. . . . . .
0x00405000 beq $t9, $s7, back
(d)
0x00403000 jal func
. . . . . .
0x0041147C func: . . .
(e)
0x00403004 back: . . .
. . . . . .
0x0040400C j back
Exerccio 6.26 Considere o seguinte fragmento de linguagem assembly MIPS. Os nmeros esquerda
de cada instruo indicam o endereo da instruo.
519
0x00400028 add $a0, $a1, $0

0x0040002C jal f2
0x00400030 f1: jr $ra
0x00400034 f2: sw $s0, 0($s2)
0x00400038 bne $a0, $0, else
0x0040003C j f1
0x00400040 else: addi $a0, $a0, 1
0x00400044 j f2
(a) Traduza a sequncia da instruo em linguagem de mquina. Escreva as instrues do cdigo
de mquina em hexadecimal
(b) Liste o modo de endereamento utilizado em cada linha do cdigo.
Exerccio 6.27 Considere o seguinte fragmento de cdigo em C:

// C code
void setArray(int num) {
int i;
int array[10];
for (i = 0; i < 10; i = i + 1) {
array[i] = compare(num, i);
}
}
int compare(int a, int b) {
if (sub(a, b) >= 0)
return 1;
else
return 0;
}
int sub(int a, int b) {
520
return a b;
}
(a) Implemente o fragmento de cdigo em C em linguagem assembly MIPS. Utilize $s0 para
manter a varivel i. Tenha certeza de manipular o apontador de pilha apropriadamente. O array
armazenado na pilha antes da funo setArray (veja Seo 6.4.6).
(b) Assuma setArray como sendo a primeira funo chamada. Desenhe o status da pilha antes
da chamada de setArray e durante cada chamada de funo. Indique os nomes dos registradores
e das variveis armazenadas na pilha, marque a localizao de $sp, e marque claramente cada
fragmento de pilha.
(c) Como o seu cdigo funcionaria se voc falhasse em armazenar $ra na pilha?
Exerccio 6.28 Considere a seguinte funo de alto nvel.

// cdigo em C
int f(int n, int k) {
int b;
b = k + 2;
if (n == 0) b = 10;
else b = b + (n * n) + f(n 1, k + 1);
return b * k;
}
(a) Traduza a funo de alto nvel f em linguagem assembly MIPS. Preste particular ateno em
como salvar apropriadamente e recuperar os registradores atravs das chamadas de funes
utilizando as convenes MIPS para os registradores preservados. Comente com clareza o seu cdigo.
Voc pode utilizar a instruo MIPS, mul. A funo inicia-se no endereo 000400100. Mantenha a
varivel local b em $s0.
521
(b) Passe atravs da sua funo da parte (a) para o caso de f(2,4). Desenhe uma figura da pilha,
similar quela na Figura 6.26 (c). Escreva o nome do registrador e o valor do dado armazenado em
cada localizao na pilha e continue acompanhando o valor do apontador de pilha ($sp). Marque
claramente cada fragmento de pilha. O leitor pode tambm achar til ficar de olho nos valores $a0,
$a1, $v0, e $s0, durante a execuo. Assuma que quando f chamada, $s0 = 0xABCD e $ra
= 0x400004. Qual o valor final de $v0?
Exerccio 6.29 Qual a faixa dos endereos de instruo para que cada desvio condicional, como beq
e bne, possam ser desviados em MIPS. D sua resposta em nmero de instrues relativos para a
instruo de desvio condicional.
Exerccio 6.30 As seguintes questes examinam as limitaes de salto de instruo, j. D sua

resposta em nmero de instrues relativas ao salto de instruo.
(a) No pior caso, o quo longe a instruo jump pode saltar para frente (isto , para endereos
maiores)? (o pior caso quando a instruo de salto no pode saltar longe). Explique utilizando
palavras e exemplos, se necessrio.
(b) No melhor caso, o quo longe a instruo de salto pode saltar para a frente? (o melhor caso
quando a instruo de salto pode saltar o mais longe possvel). Explique.
(c) No pior caso, o quo longe a instruo de salto (j) pode saltar para trs (para endereos
menores)? Explique.
(d) No melhor caso, o quo longe a instruo de salto pode saltar para trs? Explique.
Exerccio 6.31 Explique por que vantajoso ter um grande campo de endereos, addr, no
formato de mquina para as instrues de salto, j e jal.
522
Exerccio 6.32 Escreva um cdigo assembly que salte para uma instruo a 64 Minstructions da
primeira instruo. Lembre-se que 1 Minstruction = 220 instrues = 1.048.576 instrues. Assuma
que o seu cdigo inicie no endereo 000400000. Utilize o mnimo de instrues possvel.
Exerccio 6.33 Escreva uma funo em cdigo de alto nvel que receba um array com 10
elementos de 32 , armazenados no formato little endian, e converta-o para o formato big
endian. Aps escrever o cdigo de alto nvel, converta-o para cdigo assembly MIPS. Comente todo
o seu cdigo e utilize o mnimo de instrues possvel.
Exerccio 6.34 Considere duas strings: string1 e string2.
(a) Escreva um cdigo de alto nvel para uma funo chamada contat, que concatena (junta) as
duas strings: void concat(char string1, char string2[], char
stringconcat[]). A funo no retorna nenhum valor. Ela concatena string1 e string2 e
pe a string resultante em stringconcat. Assuma que o array de caracteres stringconcat
grande o suficiente para acomodar a string concatenada.
(b) Converta a funo da parte (a) em cdigo assembly MIPS.
Exerccio 6.35 Escreva um programa em assembly MIPS que adicione dois nmeros de preciso
nica e vrgula flutuante, armazenados em $s0 e $s1. No utilize nenhuma instruo MIPS para
vrgula flutuante. Voc no precisa se preocupar com nenhuma codificao reservada para
propsitos especiais (0, NANs, etc) ou nmeros com overflow ou underflow. Utilize o simulador SPIM
para testar seu cdigo. Voc precisar activar manualmente os valores de $s0 e $s1 para testar seu
cdigo. Demostre que seu cdigo funciona de forma confivel.
523
Exerccio 6.36 Mostre como o seguinte programa MIPS poderia ser carregado na memria e
executado.
main:
addi $sp, $sp, 4
sw $ra, 0($sp)
lw $a0, x
lw $a1, y
jal diff
lw $ra, 0($sp)
addi $sp, $sp, 4
jr $ra
diff:
sub $v0, $a0, $a1
jr $ra
(a) Primeiramente, mostre o endereo de instruo prximo a cada instruo assembly.
(b) Desenhe a tabela de smbolos, mostrando as labels e seus endereos.
(c) Converta todas as instrues em cdigo de mquina.
(d) Qual o tamanho (quantos bytes) dos segmentos de dados e textos?
(e) Esboce um mapa de memria mostrando onde os dados e as instrues esto armazenados.
Exerccio 6.37 Repita o Exerccio 6.36 para o seguinte cdigo assembly MIPS.
main:
addi $sp, $sp, 4
sw $ra, 0($sp)
524
addi $t0, $0, 15

sw $t0, a
addi $a1, $0, 27
sw $a1, b
lw $a0, a
jal greater
lw $ra, 0($sp)
addi $sp, $sp, 4
jr $ra
greater:
slt $v0, $a1, $a0
jr $ra
Exerccio 6.38 Mostre as instrues MIPS que implementam as seguintes pseudo-instrues.

Voc pode utilizar o registrador do assembler, $at, mas voc no deve corromper (sobrescrever)
nenhum outro registrador.
(a) addi $t0, $s2, imm31:0
(b) rol $t0, $t1, 5 (rotacionar $t1 em 5 esquerda e colocar o resultado em $t0)
(c) ror $s4, $t6, 31 (rotacionar $t6 em 31 direita e colocar o resultado em $s4)
Exerccio 6.39 Repita o Exerccio 6.38 para as seguintes pseudo-instrues.
(a) beq $t1, imm31:0, L
(b) ble $t3, $t5, L
(c) bgt $t3, $t5, L
(d) bge $t3, $t5, L
525
Os exerccios a seguir apresentam questes que tm sido perguntadas em entrevistas para empregos
em projetos digitais (mas so usualmente abertas para qualquer linguagem assembly).
Pergunta 6.1 Escreva um cdigo assembly MIPS para a troca do contedo de dois registradores, $t0 e
$t1. No deve utilizar nenhum outro registrador.
Pergunta 6.2 Suponha que lhe dado um array tanto de inteiros positivos quanto negativos. Escreva
um cdigo assembly MIPS que encontre o subconjunto do array com a maior soma. Assuma que o
endereamento de base do array e o nmero de elementos do array esto em $a0 e em $a1,
respectivamente. O seu cdigo deve colocar o subconjunto resultante do array comeando do endereo
de base $a2. Escreva um cdigo que seja o mais rpido possvel.
Pergunta 6.3 -lhe dado um array que mantm uma string em C. A string forma uma frase. Projete um
algoritmo para reverter as palavras nessa sentena, e armazenar a nova sentena de volta no array.
Implemente seu algoritmo utilizando cdigo assembly MIPS.
Pergunta 6.4 Projete um algoritmo para contar o nmero de 1 num nmero de 32-bits. Implemente
o seu algoritmo utilizando cdigo assembly MIPS.
Pergunta 6.5 Escreva um cdigo assembly MIPS para reverter os bits num registrador. Utilize o menor
nmero de instrues possvel. Assuma que o registrador de interesse o $t3.
526
Pergunta 6.6 Escreva um cdigo assembly MIPS para testar se ocorre overflow quando $t2 e
$t3 so somados. Utilize o menor nmero possvel de instrues.
Pergunta 6.7 Projete um algoritmo para testar quando uma dada string um palndromo.
Lembre-se que um palndromo uma palavra que a mesma lendo-se tanto num sentido quanto
em outro. Por exemplo, as palavras osso e reger so palndromos. Implemente o seu algoritmo
utilizando cdigo assembly MIPS.
527
528
Com a contribuio de Matthew Watkins
7. Microarquitetura
7.1. INTRODUO
Neste Captulo, o leitor vai aprender a criar um microprocessador MIPS. Na verdade, vai construir
trs verses diferentes, cada uma com diferentes solues de compromisso entre desempenho,
custo e complexidade.
Para os no iniciados, construir um microprocessador pode parecer magia negra. Mas na verdade
relativamente simples, e at aqui o leitor j aprendeu tudo o que precisa saber. Especificamente,
aprendeu a desenhar combinaes lgicas e sequenciais dadas as especificaes funcionais e
temporais. Est familiarizado com os circuitos de aritmtica e de memria. E aprendeu relativamente
arquitetura MIPS, que especifica o ponto de vista do programador do processador MIPS em termos
de registros, instrues e memria.
Este Captulo abrange a microarquitetura, que a ligao entre a lgica e a arquitetura. A
microarquitetura consiste no arranjo especfico de registros, ALU, mquinas de estados finitos (FSM),
memrias e outros blocos de construo lgica necessrios para implementar uma arquitetura. A
arquitetura em particular, como a MIPS, pode ter muitas microarquiteturas diferentes, cada uma
com diferentes vantagens e desvantagens de desempenho, custo e complexidade. Todas elas
executam os mesmos programas, mas as suas estruturas internas variam amplamente. Vamos
projetar trs microarquiteturas diferentes neste Captulo para ilustrar os compromissos.
Este Captulo baseia-se fortemente nos projetos clssicos MIPS de David Patterson e John
Hennessy do seu livro de texto Computer Organization and Design. Eles generosamente
529
Captulo sete Microarquitetura
compartilharam os seus elegantes projetos, que tm a virtude de ilustrar uma arquitetura comercial
real mas que ao mesmo tempo relativamente simples e fcil de entender.
David Patterson foi o primeiro de sua
7.1.1. Architectural State e Instruction Set
famlia a se formar na faculdade (UCLA,
1969). Ele tem sido professor de Cincia
Lembre-se que a arquitetura de computador definida pelo seu conjunto de instrues
da Computao na Universidade de (instruction set) e estado arquitetural (architectural state). O estado arquitetural para o processador
Berkeley desde 1977, onde ele co- MIPS consiste no contador de programa (program counter) e nos 32 registros. Qualquer
inventou a arquitectura RISC (Reduced microarquitetura MIPS deve conter tudo destes estados. Com base no estado arquitetural atual, o
Instruction Set Computer). Em 1984, ele processador executa uma instruo em particular com um determinado conjunto de dados para
desenvolveu a arquitetura SPARC usada produzir um novo estado arquitetural. Algumas microarquiteturas contm estados arquiteturais
pela Sun Microsystems. Ele tambm o adicionais (nonarchitectural state), seja para simplificar a lgica ou melhorar o desempenho; vamos
pai das tecnologias RAID (Redundant evidenciar isso quando surgir.
Array of Inexpensive Disks) e NOW (Rede
de Estaes de Trabalho). Para manter as microarquiteturas fceis de entender, vamos considerar apenas um subconjunto
do conjunto de instrues MIPS. Especificamente, vamos lidar com as seguintes instrues:
John Hennessy presidente da
Universidade de Stanford e tem a sido Instrues aritmticas/logicas do tipo-R: add, sub, and, or, slt
professor de Engenharia Elctrica e de
Cincia da Computao desde 1977. Co- Instrues de memria: lw, sw
inventou a arquitetura RISC. Ele
Instrues de branching: beq
desenvolveu a arquitetura MIPS em
Stanford em 1984 e co-fundador da Depois de construir as microarquiteturas com essas instrues, vamos estend-las para
MIPS Computer Systems. A partir de 2004, suportarem addi e j. Estas instrues foram escolhidas em particular, porque elas so suficientes
mais de 300 de milhes de
para escrever muitos programas interessantes. Depois de o leitor entender como implementar essas
microprocessadores MIPS foram
instrues, pode expandir o hardware para lidar com as outras.
vendidos.
No seu tempo livre, estes dois paradigmas 7.1.2. Processo de Projeto

modernos escrevem livros de texto por Vamos dividir as nossas microarquiteturas em duas partes que interagem: o caminho de dados
lazer e relaxamento. (data-path) e de controlo (control). O caminho de dados opera as words de dados. Ele possui
estruturas tais como memrias, registros, ALU, e multiplexadores. A MIPS uma arquitetura de 32-
bits, por isso vamos usar um caminho de dados de 32-bits. A unidade de controlo recebe a instruo
530
atual a partir do caminho de dados e informa o caminho de dados como executar essa instruo.
Especificamente, a unidade de controlo produz os sinais de seleo do multiplexador, enable dos
registros, e escrita da memria para controlar o funcionamento do caminho de dados.
Uma boa forma de projetar um sistema complexo comear com o hardware que contm os
elementos de estado. Esses elementos incluem as memrias e o estado arquitetural (o contador de
programa e registros). Em seguida, adicionam-se os blocos de lgica combinatria entre os elementos
de estado para calcular o novo estado com base no estado atual. Uma instruo lida de um local da
memria; as instrues de carga e armazenamento, em seguida, leem ou escrevem os dados de/para
outra parte da memria. Por isso, muitas vezes conveniente particionar a memria geral em duas
memrias menores, uma contendo as instrues e outra os dados. A Figura 7.1 mostra um diagrama
de blocos com os quatro elementos de estado: o contador de programa, o banco de registros, e as
Reiniciar o PC
memrias de instrues e de dados.
No mnimo, o contador de programa deve
ter um sinal de reset para inicializar o seu
valor quando o processador ligado. Os
processadores MIPS inicializam o
PC para 0xBFC00000 no arranque e
comeam a executar o cdigo para iniciar
o sistema operativo (OS Operating
System). O sistema operativo, em seguida,
Figura 7.1 Elementos de estado do processador MIPS carrega um programa de aplicao em
0x00400000 e comea a execut-lo. Por
Na Figura 7.1 as linhas grossas so utilizadas para indicar os barramentos de dados de 32-bits. As
simplicidade, neste captulo, vamos
linhas mdias so usadas para indicar barramentos mais estreitos, como os barramentos de 5-bits
redefinir o PC para 0x00000000 e colocar
para endereamento do banco de registros. As linhas azuis estreitas so utilizadas para indicar sinais l os nossos programas.
de controlo, como a permisso de escrita no banco de registros. Usaremos esta conveno em todo
o Captulo para evitar sobrecarregar os diagramas com a largura dos barramentos. Alm disso, os
elementos de estado tm geralmente uma entrada de reset para coloc-los num estado conhecido
no arranque. Mais uma vez, para evitar carregar os diagramas, esta entrada de reset no mostrada.
531
O contador de programa um registro de 32-bits comum. A sua sada, PC, aponta para a instruo
atual. A sua entrada, PC', indica o endereo da prxima instruo a ser executada.
A memria de instruo tem uma nica porta de leitura. Recebe uma entrada de endereo de
instrues de 32-bits, A, e l os dados de 32 bits (ou seja, de instruo) a partir desse endereo para
a sada de dados de leitura, RD.
O banco de registros de 32-elementos 32-bits tem dois portos de leitura e um porto de escrita.
Os portos de leitura tm entradas de endereo de 5-bits, A1 e A2, cada uma especificando um dos 25
= 32 registros como o operando de origem. Eles leem os valores de 32-bits do registro para as sadas
de dados lidos RD1 e RD2, respectivamente. O porto de escrita recebe uma entrada de endereo de
5-bits, A3; uma entrada de escrita de dados de 32-bits, WD; a entrada de enable de escrita, WE3; e
um relgio. Se o enable de escrita estiver a 1, o banco de registros escreve os dados no registro
especificado no flanco ascendente do relgio.
A memria de dados tem um nico porto de leitura/escrita. Se o enable de escrita, WE, estiver a
1, escreve os dados WD no endereo A no flanco ascendente do relgio. Se o enable de escrita estiver
a 0, ele l o endereo A para RD.
A memria de instrues, o banco de registros e a memria de dados so lidos atravs de
combinaes. Por outras palavras, se o endereo muda, os novos dados aparecem em RD depois de
algum atraso de propagao; sem que o relgio esteja envolvido. Eles so escritos apenas no flanco
ascendente do relgio. Desta forma, o estado do sistema alterado apenas no flanco do relgio. O
endereo, os dados e o enable de escrita devem estar estabelecidos algum momento antes do flanco
do relgio e devem permanecer estveis at um tempo de hold aps o flanco do relgio.
Porque os elementos de estado alteram o seu estado somente no flanco ascendente do relgio,
eles so circuitos sequenciais sncronos. O microprocessador constitudo por elementos de estado
chaveados e lgica combinatria, por isso tambm um circuito sequencial sncrono. Com efeito, o
processador pode ser visto como uma mquina de estado finito gigante, ou como um conjunto de
mquinas de estado mais simples que interagem.
532
7.1.3. Microarquitetura MIPS

Neste Captulo, desenvolvemos trs microarquiteturas: de ciclo-nico, multi-ciclo e pipeline. Elas
diferem na forma em que os elementos de estado so ligados entre si e na quantidade de estados
arquiteturais adicionais.
A microarquitetura de ciclo-nico (single-cycle microarchitecture) executa uma instruo inteira
em cada ciclo. fcil de explicar e tem uma unidade de controlo simples. Porque ela completa a
operao num ciclo, no requer qualquer estado arquitetural adicional. No entanto, o tempo de ciclo
limitado pela instruo mais lenta.
A microarquitetura multi-ciclo (multicycle microarchitecture) executa instrues numa srie de
ciclos mais curtos. As instrues mais simples executam em menos ciclos do que as mais complicadas.
Alm disso, a microarquitetura multi-ciclo reduz o custo do hardware atravs da reutilizao de
blocos de hardware caros, como somadores e memrias. Por exemplo, o somador pode ser usado em
vrios ciclos diferentes para vrios fins durante a realizao de uma nica instruo. Para isso, o
microprocessador multi-ciclo acrescenta vrios registros de estados arquiteturais adicionais, para
manter os resultados intermedirios. O processador multi-ciclo executa somente uma instruo de
cada vez, mas cada instruo leva vrios ciclos de relgio.
A microarquitetura com pipeline aplica o pipelining microarquitetura de ciclo-nico. Por
conseguinte, possvel executar vrias instrues, simultaneamente, melhorando significativamente
o rendimento. O pipelining requer a adio de lgica para lidar com as dependncias entre instrues
executadas simultaneamente. Tambm requer registros de pipelining arquiteturais adicionais. A
lgica e os registros adicionados valem a pena; hoje todos os processadores de alto desempenho
comerciais usam pipelining.
Exploramos os detalhes e os compromissos destas trs microarquiteturas nas seces
subsequentes. No final do Captulo, mencionamos brevemente as tcnicas adicionais que so usadas
para obter ainda maior velocidade nos microprocessadores modernos de alto desempenho.
533
7.2. ANLISE DE DESEMPENHO

Como j mencionamos, uma arquitetura de processador em particular pode ter muitas
microarquiteturas com diferentes vantagens e desvantagens de custo e desempenho. O custo
depende da quantidade de hardware requerida e a tecnologia de implementao. A cada ano, os
processos CMOS permitem empacotar mais transstores num chip pela mesma quantidade de
dinheiro, e os processadores tiram proveito desses transstores adicionais oferecendo maior
desempenho. Os clculos detalhados dos custos exigem um conhecimento detalhado da tecnologia
de implementao, mas, em geral, mais portas e mais memria significam mais dlares. Esta seo
estabelece as bases para analisar o desempenho.
H muitas formas de medir o desempenho de um sistema computacional, e os departamentos de
marketing so infames por escolherem o mtodo que faz com que o seu computador parea mais
rpido, independentemente se a medida tem qualquer correlao com o desempenho no mundo
real. Por exemplo, a Intel e a Advanced Micro Devices (AMD), ambas vendem microprocessadores
compatveis em conformidade com a arquitetura x86. Os microprocessadores Intel Pentium III e
Pentium 4 foram amplamente anunciados de acordo com a frequncia do relgio no final de 1990 e
incio de 2000, porque a Intel oferecia frequncias de relgio mais altas do que os seus concorrentes.
No entanto, o principal concorrente da Intel, a AMD, vendia o microprocessador Athlon que
executava programas mais rpido do que os chips da Intel com a mesma frequncia de relgio. O que
deve um consumidor fazer?
A nica maneira livre de chamariz para medir o desempenho atravs da medio do tempo de
execuo de um programa que interesse ao leitor. O computador que executar mais rpido o seu
programa tem a performance mais alta. A prxima melhor opo medir o tempo total de execuo
de um conjunto de programas que so semelhantes aos que o leitor pretende executar; isso pode ser
necessrio se o leitor no tiver ainda escrito o programa ou se outra pessoa que no tem o seu
programa est fazendo as medies. Tais colees de programas so chamados de benchmarks, e os
tempos de execuo destes programas so comumente publicados para dar alguma indicao de
como um processador executa.
534
O tempo de execuo de um programa, medido em segundos, dado pela equao 7.1.

= (# ) () ( ) (7.1)

O nmero de instrues num programa depende da arquitetura do processador. Algumas

arquiteturas tm instrues complicadas que fazem mais trabalho por instruo, reduzindo assim o
nmero de instrues de um programa. No entanto, estas instrues complicadas so muitas vezes
mais lentas para executar em hardware. O nmero de instrues tambm depende enormemente da
destreza do programador. No final deste Captulo, vamos assumir que estamos executando
programas conhecidos num processador MIPS, de modo que o nmero de instrues para cada
programa constante, independente da microarquitetura.
O nmero de ciclos por instruo, muitas vezes chamado de CPI (cycles per instruction), o nmero
de ciclos de relgio necessrios para executar uma instruo mdia. o inverso da taxa de
transferncia (instrues por ciclo, ou IPC (instruction per cycles)). Diferentes microarquiteturas tm
diferentes CPI. Neste Captulo, vamos supor que temos um sistema de memria ideal que no afeta
o CPI. No Captulo 8, examinamos como o processador, por vezes, tem que esperar pela memria, o
que aumenta o CPI.
O nmero de segundos por ciclo o perodo de relgio, Tc. O perodo de relgio determinado
pelo caminho crtico atravs da lgica do processador. Diferentes microarquiteturas tm diferentes
perodos de relgio. O projeto da lgica e dos circuitos tambm afetam significativamente o perodo
de relgio. Por exemplo, um somador carry-lookahead mais rpido do que um somador ripple-carry.
Historicamente, os avanos na fabricao duplicaram a velocidade dos transstores a cada 4-6 anos,
ento um microprocessador construdo hoje ser muito mais rpido do que um da ltima dcada,
mesmo se a microarquitetura e a lgica no tenham sido alteradas.
O desafio do microarquiteto escolher o projeto que minimize o tempo de execuo, desde que
satisfaa as restries sobre o custo e/ou o consumo de energia. Como as decises microarquiteturas
afetam tanto o CPI como o Tc e so influenciadas pelo projeto da lgica e dos circuitos, determinar a
melhor escolha exige uma anlise cuidadosa.
535
H muitos outros fatores que afetam o desempenho geral do computador. Por exemplo, o disco
rgido, a memria, o sistema grfico, e a ligao de rede podem ser fatores limitadores que tornam o
desempenho do processador irrelevante. O microprocessador mais rpido do mundo no ajuda a
navegar na Internet com uma ligao dial-up. Mas esses outros fatores esto alm do objetivo deste
livro.
7.3. PROCESSADORES DE CICLO-NICO

Em primeiro lugar criamos uma microarquitetura MIPS que executa instrues num nico ciclo.
Vamos comear por construir o caminho de dados, ligando os elementos de estado da Figura 7.1 com
a lgica combinatria que podem executar as vrias instrues. Os sinais de controlo determinam
que instruo especfica levada a cabo pelo caminho de dados a qualquer momento. O controlador
contm lgica combinatria que gera os sinais de controlo adequados com base na instruo atual.
Conclumos, analisando o desempenho do processador de ciclo-nico.
7.3.1. Caminho de Dados de Ciclo-nico
Esta seo desenvolve gradualmente o caminho de dados de ciclo-nico, acrescentando uma pea
de cada vez aos elementos de estado da Figura 7.1. As novas ligaes so enfatizadas a preto (ou a
azul, para os novos sinais de controlo), enquanto o hardware j estudado mostrado a cinza.
O registro contador de programa (PC) contm o endereo da instruo a executar. O primeiro
passo ler esta instruo da memria de instrues. A Figura 7.2 mostra que o PC est simplesmente
ligado entrada de endereo da memria de instrues. A memria de instrues l, ou fetches, a
instruo de 32-bits, identificada como Instr.
As aes do processador dependem da instruo especfica que foi lida. Primeiro vamos trabalhar
as ligaes do caminho de dados para a instruo lw. Em seguida, vamos considerar como generalizar
o caminho de dados para lidar com as outras instrues.
536
Figura 7.2 Leitura (fetch) de instruo da memria
Para uma instruo lw, o prximo passo ler o registro de origem que contm o endereo de base.
Este registro especificado no campo rs da instruo, Instr25:21. Estes bits da instruo esto ligados
entrada de endereo de um dos portos de leitura do banco de registros, A1, tal como mostrado na
Figura 7.3. O banco de registros l o valor de registro em RD1.
A instruo lw tambm requer um offset. O offset armazenado no campo imediato da instruo,

Instr15:0. Uma vez que o 16-bit imediato pode ser positivo ou negativo, ele deve ter o sinal estendido
para 32 bits, como mostrado na Figura 7.4. O valor de 32 bits de sinal estendido chamado SignImm.
Lembre-se da Seo 1.4.6 que a extenso do sinal simplesmente copia o bit de sinal (bit mais
significativo) de uma entrada para todos os bits superiores da sada. Especificamente, SignImm15:0 =
Instr15: 0 e SignImm31:16 = Instr15.
Figura 7.3 Leitura do operando de origem do banco de registros
537
Figura 7.4 Extenso de sinal imediato
O processador deve adicionar o endereo de base ao offset para encontrar o endereo a ler a partir
da memria. A Figura 7.5 introduz uma ALU para realizar esta adio. A ALU recebe dois operandos,
SrcA e SrcB. O SrcA vem do banco de registros, e o SrcB vem do imediato com extenso de sinal. A
ALU pode realizar vrias operaes, como foi descrito no Seo 5.2.4. O sinal de 3-bits de controlo da
ALU especifica a operao. A ALU gera um ALUResult de 32-bits e uma flag Zero, que indica se
ALUResult == 0. Para uma instruo lw, o sinal de controlo da ALU deve ser definido como 010 para
adicionar o endereo de base e o offset. O ALUResult enviado para a memria de dados como o
endereo da instruo de carregamento, conforme mostrado na Figura 7.5.
Os dados so lidos a partir da memria de dados para o ReadBus, em seguida, escrita de volta
para o registro de destino no banco de registros no final do ciclo, como mostrado na Figura 7.6. O
Porto 3 do banco de registros o porto de escrita.
538
Figura 7.5 Endereamento de memria do computador
Figura 7.6 Escrita de retorno dos dados no registro
539
O registro de destino para a instruo lw especificado no campo rt, Instr20:16, o qual est ligado
entrada de endereo do porto 3, A3, do banco de registros. Em seguida, o barramento de leitura de
dados ReadData est ligado entrada de escrita de dados do porto 3, WD3, do banco de registros.
Um sinal de controlo chamado de RegWrite est ligado entrada de enable de escrita do porto 3,
WE3, e ativado durante uma instruo lw para que o valor do dado seja escrito no banco de
registros. A escrita ocorre no flanco ascendente do relgio no final do ciclo.
Enquanto a instruo est a ser executada, o processador deve calcular o endereo da prxima
instruo, PC'. Porque as instrues tm 32 bits = 4 bytes, a prxima instruo est em PC + 4. A
Figura 7.7 utiliza outro somador para incrementar o PC de 4. O novo endereo escrito no contador
de programa no prximo flanco ascendente do relgio. Isto completa o caminho de dados para a
instruo lw.
Figura 7.7 Determinao do endereo da prxima instruo para o PC
540
Figura 7.8 Escrita de dados na memria para a instruo sw
Em seguida, vamos estender o caminho de dados para lidar tambm com a instruo sw. Tal como
a instruo lw, a instruo sw l um endereo base do porto 1 do banco de registros e estende o sinal
do imediato. A ALU soma ao endereo de base ao imediato para encontrar o endereo de memria.
Todas estas funes j so suportadas pelo caminho de dados.
A instruo sw tambm l um segundo registro do banco de registros e escreve-o para a memria

de dados. A Figura 7.8 mostra as novas ligaes para esta funo. O registro especificado em rt no
campo Instr20:16. Estes bits da instruo esto ligados ao segundo porto de leitura do banco de registros,
A2. O valor do registro lido para o porto RD2. Ele est ligado ao porto de escrita de dados da memria
de dados. O porto de enable de escrita da memria de dados, WE, controlado por MemWrite. Para
uma instruo de sw, MemWrite = 1, para escrever os dados para a memria; ALUControl = 010, para
adicionar o endereo de base ao offset; e RegWrite = 0, porque nada deve ser escrito para o banco de
registro. Note-se que os dados ainda so lidos a partir do endereo fornecido memria de dados, mas
este ReadData ignorado porque RegWrite = 0.
541
Em seguida, vamos considerar o alargamento do caminho de dados para lidar com as instrues
do tipo-R add, sub, and, or, e slt. Todas estas instrues leem dois registros do banco de registro,
executam alguma operao da ALU sobre eles, e escrevem o resultado de volta para um terceiro
registro do banco de registros. Elas diferem apenas na operao especfica da ALU. Assim, elas podem
ser tratadas com o mesmo hardware, atravs de sinais diferentes de controlo da ALU.
A Figura 7.9 mostra o caminho de dados melhorada para manipulao de instrues do tipo-R. O
banco de registros l dois registros. A ALU executa uma operao nesses dois registros. Na Figura 7.8,
a ALU recebe sempre o seu operando SrcB do imediato com extenso de sinal (SignImm). Agora,
acrescentemos um multiplexador para escolher o SrcB a partir do porto RD2 do banco de registros
ou de SignImm.
O multiplexador controlado por um novo sinal, ALUSrc. O ALUSrc 0 para as instrues do tipo-
R para escolher SrcB a partir do banco de registros; 1 para lw e sw para escolher SignImm. Este
princpio de melhorar as capacidades do caminho de dados atravs da adio de um multiplexador
para escolher as entradas de entre as vrias possibilidades extremamente til. Na verdade, vamos
aplic-lo mais duas vezes para completar o tratamento de instrues do tipo-R.
Na Figura 7.8, o banco de registro tem sempre os seus dados escritos da memria de dados. No
entanto, as instrues do tipo-R escrevem o ALUResult para o banco de registros. Portanto,
adicionamos outro multiplexador para escolher entre Read-Data e ALUResult. Chamamos sada
Result. Este multiplexador controlado por um outro sinal novo, MemtoReg. O MemtoReg est a 0
para as instrues do tipo-R para escolher Result de ALUResult; 1 para lw para escolher ReadData.
No nos preocupamos com o valor de MemtoReg de sw, porque sw no escreve para o banco de
registros.
Da mesma forma, na Figura 7.8, o registro de escrita foi especificado pelo campo rt da instruo,
Instr20:16. No entanto, para obter instrues do tipo-R, o registro especificado pelo campo rd,
Instr15:11. Assim, acrescentamos um terceiro multiplexador para escolher WriteReg do campo
apropriado da instruo. O multiplexador controlado por RegDst. RegDst de 1 para instrues do
tipo-R para escolher WriteReg do campo rd, Instr15:11; 0 para lw para escolher o campo certo, Instr
542
20:16.No nos preocupamos com o valor de RegDst de sw, porque sw no escreve para o banco de
registros.
Figura 7.9 Caminho de dados melhorado para instrues do tipo-R
Finalmente, vamos estender o caminho de dados para lidar com a instruo beq. A instruo beq
compara dois registros. Se eles forem iguais, o branch obtido adicionando o offset ao contador de
programa. Recorde-se que o offset um nmero positivo ou negativo, armazenado no campo imm da
instruo, Instr15:0. O offset indica o nmero de instrues para o branch passar. Por isso, o imediato deve
ter o sinal estendido e multiplicado por 4 para obter o novo valor do contador de programa: PC '= PC + 4
+ SignImm 4.
A Figura 7.10 apresenta as modificaes do caminho de dados. O prximo valor do PC para um branch,
PCBranch, calculado deslocando SignImm para a esquerda por 2 bits para, em seguida, adicion-lo ao
543
PCPlus4. O deslocamento para a esquerda por 2 uma maneira fcil de multiplicar por 4, porque um
deslocamento por um valor constante envolve apenas fios. Os dois registros so comparados por
clculo de SrcA - SrcB usando a ALU. Se o ALUResult 0, como indicado pela flag Zero da ALU, os
registros so iguais. Adicionamos um multiplexador para escolher PC' a partir de PCPlus4 ou de
PCBranch. O PCBranch selecionado se a instruo um branch e a flag Zero est ativada. Assim,
Branch 1 para beq e 0 para as outras instrues. Para beq, ALUControl = 110, de modo que a ALU
efectua uma subtraco. ALUSrc = 0 para escolher SrcB a partir do banco de registros. RegWrite e
MemWrite so 0, porque um branch no escreve para o banco de registros ou para a memria. No
nos preocupamos com os valores de RegDst e MemtoReg, porque o banco de registros no escrito.
Isto completa o projeto do processador MIPS de caminho de dados de ciclo-nico. Ilustrmos no
s o projeto em si, mas tambm o processo de projeto em que os elementos de estado so
identificados e a lgica combinatria que liga os elementos de estado sistematicamente
acrescentada. Na prxima seo, abordamos como determinar os sinais de controlo que dirigem a
operao do nosso caminho de dados.
Figura 7.10 Caminho de dados melhorado para a instruo beq
544
7.3.2. Controlo de Ciclo-nico

A unidade de controlo determina os sinais de controlo com base nos campos do opcode e funct da
instruo, Instr31:26 e Instr5:0. A Figura 7.11 apresenta todo o processador MIPS de ciclo-nico, com a
unidade de controlo ligada ao caminho de dados.
A maior parte da informao de controlo vem do cdigo do opcode, mas as instrues do tipo-R
tambm usar o campo func para determinar a operao ALU. Assim, vamos simplificar a nossa
concepo decompondo a unidade de controlo em dois blocos de lgica combinatria, como
mostrado na Figura 7.12 Estrutura interna da unidade de controlo. O decodificador principal
determina a maior parte das sadas do opcode. Ele determina tambm o sinal de 2-bits OpALU. O
decodificador da ALU utiliza este sinal OpALU em conjunto com o campo func para calcular
ALUcontrol. O significado do sinal OpALU dado na Tabela 7.1.
Figura 7.11 Processador MIPS complete de Ciclo-nico
545
Tabela 7.1 Codificao do ALUop
A Tabela 7.2 uma tabela verdade para o decodificador da ALU. Recorde-se que os significados
dos trs sinais de controlo da ALU foram dados na Tabela 5.1.. Porque OpALU nunca 11, a tabela
verdade pode usar dont care X1 e 1X, em vez de 01 e 10 para simplificar a lgica. Quando o OpALU
00 ou 01, a ALU deve adicionar ou subtrair, respectivamente. Quando OpALU 10, o decodificador
Figura 7.12 Estrutura interna da examina o campo funct para determinar o controlo da ALU. Note-se que, para as instrues do tipo-
unidade de controlo R que implementamos, os dois primeiros bits do campo funct so sempre 10, portanto, podem ser
ignoradas para simplificar o decodificador .
Os sinais de controlo para cada instruo foram descritos enquanto construmos o caminho de
dados. A Tabela 7.3 uma tabela verdade para o decodificador principal que resume os sinais de
controlo em funo do opcode. Todas as instrues do tipo-R usam os mesmos valores do
decodificador principal; eles diferem apenas na sada do decodificador da ALU. Lembre-se que, para
instrues que no escrevam para o banco de registros (por exemplo, sw e beq), os sinais de
controlo RegDst e MemtoReg so dont care (X); o endereo e os dados para o porto de escrita do
registro no importam, porque RegWrite no est ativo. A lgica para o decodificador pode ser
projetada usando as suas tcnicas favoritas para o projeto de lgica combinatria.
546
Tabela 7.2 Tabela de descodificao da ALU
Tabela 7.3 Tabela verdade do decodificador principal
Exemplo 7.1 OPERAO DO PROCESSADOR DE CICLO-NICO

Determinar os valores dos sinais de controlo e as pores do caminho de dados que so usadas
durante a execuo de uma instruo or.
Soluo: A Figura 7.13 ilustra os sinais de controlo e fluxo de dados durante a execuo da instruo
OR. O PC aponta para a localizao de memria que contm a instruo, e a memria de instrues
recolhe a instruo.
O fluxo de dados principal entre o banco de registros e a ALU representado com uma linha
tracejada azul. O banco de registros l os dois operandos de origem especificados pelo Instr25:21 e
547
Instr20:16. O SrcB deve vir da segunda porta do banco de registros (NOT SignImm), de modo que
ALUSrc deve ser 0. O or uma instruo do tipo-R, de modo que OpALU 10, indicando que
ALUControl deve ser determinado a partir do campo funct para ser 001. O Result obtido da ALU,
logo MemtoReg 0. O resultado escrito para o banco de registros, de modo que RegWrite 1. A
instruo no escreve na memria, assim MemWrite = 0.
A seleo do registro de destino tambm mostrada com uma linha tracejada azul. O registro de
destino especificado no campo rd, Instr15:11, portanto RegDst = 1.
A atualizao do PC mostrada com a linha cinza tracejada. A instruo no um branch, de logo
teremos branch = 0 e, por conseguinte, tambm PCSrc 0. O PC recebe o prximo valor de PCPlus4.
Figura 7.13 Sinais de controlo e fluxo de dados no decorrer da execuo de uma instruo or
548
Note-se que os dados certamente se escoam atravs dos caminhos no destacados, mas o valor
destes dados no importante para esta instruo. Por exemplo, o imediata tem o sinal estendido e
os dados so lidos a partir da memria, mas estes valores no influenciam o estado seguinte do
sistema.
7.3.3. Mais Instrues

Considermos um subconjunto limitado de todo o conjunto de instrues MIPS. Adicionando
suporte para as instrues addi e j ilustra o princpio de como lidar com as novas instrues e
tambm nos d uma instruo suficientemente rica para escrever muitos programas interessantes.
Veremos que para apoiar algumas instrues simplesmente necessrio melhorar o decodificador
principal, enquanto que apoiar outras tambm requer mais hardware no caminho de dados.
Exemplo 7.2 INSTRUO ADDI
A instruo imediata de soma, addi, adiciona o valor de um registro ao valor imediato e escreve o
resultado para outro registro. O caminho de dados j capaz de realizar esta tarefa. Determine as
mudanas necessrias para que o controlador para que possa suportar addi.
Soluo: Tudo o que precisamos fazer adicionar uma nova linha tabela verdade do decodificador
principal, mostrando os valores do sinal de controlo para addi, tal como consta da Tabela 7.4. O
resultado deve ser escrito para o banco de registros, de modo que RegWrite = 1. O registro de destino
especificado no campo rt da instruo, de modo que RegDst = 0. O SrcB vem do imediato, assim
ALUSrc = 1. A instruo no um branch, nem escreve na memria, assim Branch = MemWrite = 0. O
resultado vem da ALU, no da memria, de modo que MemtoReg = 0. Finalmente, a ALU deve
adicionar, por isso ALUOp = 00.
549
Tabela 7.4 Tabela verdade do decodificador principal melhorado para suportar addi
Exemplo 7.3 Instruo j
A instruo de salto, j, escreve um novo valor para o PC. Os dois bits menos significativos do PC
esto sempre 0, porque o PC est alinhado com a palavra (isto , sempre um mltiplo de 4). Os
prximos 26 bits so retirados do campo de endereo de salto em Instr25:0. Os quatro bits superiores
so retirados do valor antigo do PC.
O caminho de dados existente carece de hardware para calcular PC' desta forma. Determine as
mudanas necessrias tanto para o caminho de dados como para o controlador para lidar com j.
Soluo: Em primeiro lugar, preciso acrescentar o hardware para calcular o prximo valor do PC,
PC', no caso de uma instruo J e de um multiplexador para selecionar o prximo PC, como mostrado
na Figura 7.14. O novo multiplexador usa o novo sinal de controle Jump.
Agora, temos de adicionar uma linha tabela verdade do decodificador principal para a instruo
j e uma coluna para o sinal Jump, como mostra a Tabela 7.5. O sinal de controlo Jump est a 1 para
a instruo j e a 0 para todos as outras. A Instruo J no escreve no banco de registros ou na
memria, de modo que RegWrite = MemWrite = 0. Portanto, no nos preocupamos com os clculos
realizados no caminho de dados, e RegDst = ALUSrc = Branch = MemtoReg = ALUOp = X.
550
Figura 7.14 Caminho de dados MIPS de ciclo-nico melhorado para suportar a instruo j
551
Tabela 7.5 Tabela verdade do decodificador melhorado para suportar j
7.3.4. Anlise de Desempenho

Cada instruo no processador de ciclo-nico requer um ciclo de relgio, de modo que o CPI 1.
O caminho crtico para a instruo lw mostrado na Figura 7.15 com uma linha tracejada azul
escura. Ele comea com o PC a carregar um novo endereo no flanco de subida do relgio. A
memria de instruo l a prxima instruo. O banco de registros l SrcA. Enquanto o banco de
registros faz a leitura, realizada a extenso do sinal do campo imediato e selecionado no
multiplexor ALUSrc para determinar SrcB. A ALU acrescenta SrcA e SrcB para encontrar o endereo
efetivo. A memria de dados l a partir deste endereo. O multiplexador MemtoReg seleciona
ReadData. Finalmente, o Result deve preparar o banco de registros antes da prxima transio de
flanco ascendente do relgio, de modo que ele possa ser devidamente escrito. Assim, o tempo de
ciclo
= + + max[ , + ] + + + + (7.2)
Na maioria das tecnologias de implementao, os acessos ALU, memria e banco de registros

so substancialmente mais lentos do que as outras operaes. Portanto, o tempo de ciclo
simplificado para
= + 2 + + + + + (7.3)
Os valores numricos destes tempos iro depender da tecnologia de implementao especfica.
552
Outras instrues tm caminhos crticos mais curtos. Por exemplo, as instrues tipo-R no
precisa aceder memria de dados. No entanto, disciplinamo-nos concepo sequencial sncrona,
de modo que o perodo de relgio constante e deve ser longo o suficiente para acomodar a
instruo mais lenta.
Figura 7.15 Caminho crtico da instruo lw
Exemplo 7.4 DESEMPENHO DE UM PROCESSADOR DE CICLO-NICO

Ben Bitdiddle est contemplando a construo do processador MIPS de ciclo-nico num processo
de fabricao CMOS de 65 nm. Ele concluiu que os elementos lgicos tm os atrasos apresentados
na Tabela 7.6. Ajude a calcular o tempo de execuo de um programa com 100 bilhes de instrues.
Soluo: De acordo com a Equao 7.3, o tempo de ciclo do processador de ciclo-nico Tc1 = 2 + 30
(250) + 150 + 200 + 25 + 20 = 925 ps. Usamos o ndice "1" para distingui-lo dos modelos de
processador subsequentes. De acordo com a Equao 7.1, o tempo total de execuo T1 = (100
109 instrues) (1 ciclo / instruo) (925 10-12 s /ciclo) = 92,5 segundos.
553
Tabela 7.6 Atrasos dos elementos do circuito
7.4. PROCESSADOR MULTI-CICLO

O processador de ciclo-nico tem trs fraquezas principais. Em primeiro lugar, requer um ciclo de
relgio longo o suficiente para suportar a instruo mais lenta (lw), embora a maioria das instrues
sejam mais rpidas. Em segundo lugar, exige trs somadores (um na ALU e dois na lgica de PC); os
somadores so circuitos relativamente caros, especialmente se eles devem ser rpidos. E em terceiro
lugar, tem memrias de instruo e de dados separadas, o que pode no ser realista. A maioria dos
computadores tem uma nica memria grande que mantm as instrues e os dados e que podem
ser lidas e escritas.
O processador multi-ciclo aborda estas deficincias, quebrando uma instruo em vrios passos
mais curtos. Em cada pequeno passo, o processador pode ler ou escrever na memria ou banco de
registros ou usar a ALU. Diferentes instrues usam diferentes nmeros de passos, de modo que as
instrues mais simples podem ser executadas mais rapidamente do que as mais complexas. O
processador precisa de apenas um somador; este componente reutilizado para diferentes fins nos
diversos estgios. E o processador usa uma memria combinada para instrues e dados. A instruo
554
obtida a partir da memria no primeiro passo, e os dados podem ser lidos ou escritos nos estgios
posteriores.
Projetamos um processador multi-ciclo seguindo o mesmo procedimento que foi utilizado para o
processador de ciclo-nico. Em primeiro lugar, construir um caminho de dados, ligando os elementos
de estado de arquitetura e as memrias com a lgica combinatria. Mas, desta vez, tambm devemos
adicionar os elementos de estado no-arquitetural para manter os resultados intermedirios entre os
passos. Projetamos ento o controlador. O controlador produz sinais diferentes em diferentes
estgios durante a execuo de uma nica instruo, por isso agora uma mquina de estado finita
em vez de lgica combinatria. Voltamos a analisar a forma de adicionar novas instrues ao
processador. Finalmente, analisamos o desempenho do processador multi-ciclo e comparamo-lo com
o processador de ciclo-nico.
7.4.1. Caminho de Dados Multi-ciclo
Mais uma vez, comeamos o nosso projeto com a memria e o estado de arquitetura do
processador MIPS, mostrada na Figura 7.16. Na concepo de ciclo-nico, usamos memrias de
instrues e dados separadas porque necessrio ler a memria de instruo e ler ou escrever a
memria de dados num ciclo. Agora, optamos por usar uma memria combinada para ambas as
instrues e dados. Isto mais realista, e vivel porque podemos ler a instruo num ciclo, em
seguida, ler ou escrever os dados num ciclo separado. O PC e o banco de registros permanecem
inalterados. Gradualmente construmos o caminho de dados atravs da adio de componentes para
lidar com cada estgio de cada instruo. As novas ligaes so enfatizadas em preto (ou azul, para
os novos sinais de controle), enquanto o hardware que j foi estudado mostrado em cinza.
O PC contm o endereo da instruo a executar. O primeiro passo ler esta instruo da memria
de instrues. A Figura 7.17 mostra que o PC est simplesmente ligado entrada de endereo da
memria de instrues. A instruo lida e armazenada num novo Registro de Instruo no
arquitetural de modo a que esteja disponvel para ciclos futuros. O Registro de Instruo recebe um
sinal de habilitao, chamado IRWrite, que ativado quando deve ser atualizado com uma nova
instruo.
555
Figura 7.16 Elementos de estado com memria unificada de instrues/dados
Figura 7.17 Obtendo a instruo da memria
Como fizemos com o processador de ciclo-nico, vamos trabalhar as conexes do caminho de

dados para a instruo lw. Ento, vamos melhorar o caminho de dados para lidar com as outras
instrues. Para uma instruo lw, o prximo passo ler o registro de origem que contm o endereo
de base. Este registro especificado no campo rs da instruo, Instr25:21. Estes bits da instruo so
conectados a uma das entradas de endereos, A1, do banco de registros, como mostrado na Figura
7.18. O banco de registros l o registro para RD1. Este valor armazenado noutro registro no
arquitetural, A.
A instruo lw tambm requer um deslocamento. O deslocamento armazenado no campo

imediato da instruo, Instr15:0, e deve ter o sinal estendido para 32-bits, como mostrado na Figura
7.19. O valor de 32-bits de sinal estendido chamado de SignImm. Para ser coerente, podemos
armazenar SignImm noutro registro no arquitetural. No entanto, SignImm uma funo
556
combinatria de Instr e no vai mudar enquanto a instruo atual est sendo processada, por isso
no h necessidade de dedicar um registro para manter o valor constante.
O endereo da carga a soma do endereo de base e do deslocamento. Usamos uma ALU para
calcular esta soma, como mostrado na Figura 7.20. O ALUControl deve ser definido como 010 para
executar uma soma. O ALUResult armazenado num registro no arquitetural chamado ALUOut.
Figura 7.18 Leitura do operando fonte do banco de registros
O prximo passo carregar os dados do endereo calculado na memria. Adicionamos um

multiplexador em frente da memria para escolher o endereo de memria, Adr, seja a partir do PC
ou do ALUOut, como mostrado na Figura 7.21. O sinal de seleo do multiplexador chamado IorD,
para indicar tanto um endereo de instruo como de dados. Os dados lidos a partir da memria so
armazenados noutro registro no arquitetural, chamada de Data. Observe que o multiplexador de
endereos permite reutilizar a memria durante a instruo lw. No primeiro passo, o endereo
tomado a partir do PC para obter a instruo. Num passo posterior, o endereo obtido a partir de
ALUOut para carregar os dados. Assim, IorD deve ter valores diferentes em diferentes estgios. Na
Seo 7.4.2, desenvolvemos o controlador FSM que gera essas sequncias de sinais de controlo.
557
Figura 7.19 Extenso do sinal do imediato
Figura 7.20 Adio do endereo de base ao offset
Figura 7.21 Carregamento de dados da memria

558
Finalmente, os dados so gravados de volta para o banco de registros, como mostrado na Figura
7.22. O registro de destino especificado pelo campo rt da instruo, Instr20:16.
Enquanto tudo isso est acontecendo, o processador deve atualizar o contador de programa,
adicionando 4 para o PC antigo. No processador de ciclo-nico, era necessrio um somador em
separado. No processador multi-ciclo, podemos utilizar a ALU existente num dos passos quando no
est ocupada. Para fazer isso, devemos inserir multiplexadores de origem para escolher o PC e a
constante 4 como entradas da ULA, como mostrado na Figura 7.23. Um multiplexador de duas
entradas controladas por ALUSrcA escolhe o PC ou o registro A como SrcA. Um multiplexador de
quatro entradas controladas por ALUSrcB escolhe 4 ou Sign-Imm como SrcB. Usamos as outras duas
entradas do multiplexador mais tarde, quando estendemos o caminho de dados para lidar com outras
instrues. (A numerao das entradas para o multiplexador arbitrria.) Para atualizar o PC, a ALU
soma SrcA (PC) a SrcB (4), e o resultado escrito no registro contador de programa. O sinal de controlo
PCWrite permite que o registro PC seja escrito apenas em determinados ciclos.
Figura 7.22 Escrita de dados no banco de registros
559
Figura 7.23 Incrementado o PC de 4
Isso completa o caminho de dados para a instruo lw. Em seguida, vamos estender o caminho
de dados para lidar tambm com a instruo sw. Como a instruo lw, a instruo sw l um endereo
base da porta 1 do banco de registros e estende o sinal do imediato. A ALU soma o endereo de base
ao imediato para encontrar o endereo de memria. Todas estas funes j so suportadas pelo
hardware existente no caminho de dados.
A nica caracterstica nova da sw que devemos ler um segundo registro do banco de registros e
escrev-lo para a memria, como mostrado na Figura 7.24. O registro especificado no campo de rt
de instrues, Instr20:16, o qual est ligado segunda porta do banco de registros. Quando o registro
lido, ele armazenado num registro no arquitetural, B. No passo seguinte, ele enviado para a
porta de escrita de dados (WD) da memria de dados a ser escrita. A memria recebe um sinal de
controlo MemWrite adicional para indicar que a escrita deve ocorrer.
560
Figura 7.24 Caminho de dados melhorado para suportar a instruo sw
Figura 7.25 Caminho de dados melhorado para instrues do tipo-R
Para obter instrues do tipo-R, a instruo novamente obtida, e os dois registros de origem so
lidos a partir do banco de registros. A ALUSrcB1:0, a entrada de controle do multiplexador SrcB,
utilizado para escolher o registro B como o segundo registro de origem para a ALU, como mostrado
na Figura 7.25. A ALU executa a operao apropriada e armazena o resultado em ALUOut. No prximo
estgio, ALUOut escrito de volta para o registro especificado pelo campo rd da instruo, Instr15:11.
Isto requer dois novos multiplexadores. O multiplexador MemtoReg selecciona se WD3 vem de
ALUOut (para instrues tipo-R) ou de Data (para lw). A instruo RegDst selecciona se o registro de
destino especificado no campo rt ou rd da instruo.
561
Figura 7.26 Caminho de dados melhorado para a instruo beq
Para as instrues beq, a instruo outra vez obtida, e os dois registros de fonte so lidos do
banco de registros. Para determinar se os registros so iguais, a ALU subtrai os registros e, quando o
resultado zero, a flag Zero ativada. Entretanto, o caminho de dados deve determinar o prximo
valor do PC se o branch for necessrio: PC = PC + SignImm 4. No processador de ciclo-nico de
instruo, foi acrescentado outro somador destinado a determinar o endereo de branch. No
processador multi-ciclo, a ALU pode ser utilizada novamente para economizar hardware. No primeiro
passo, a ALU determina PC + 4 e coloca o resultado no program counter, como realizado para as
outras instrues. Noutro passo, a ALU utiliza este valor atualizado do PC para determinar PC + Sign-
Imm 4. Sign-Imm deslocado 2 vezes para a direita para o multiplicar por 4, como demonstrado na
Figura 7.26. O multiplexador SrcB escolhe este valor e soma-o ao PC. Esta soma representa o destino
do Branch e armazenado no ALUOut. Outro multiplexar controlado pelo PCScr, escolhe que sinal
deve ser enviado para o PC. O program counter deve ser escrito quando o PCWriter ativado ou
quando um Branch executado. Um novo sinal de controlo, Branch, indica quando a instruo beq
est a ser executada. O Branch executado se Zero tambm ativado. Assim, o caminho de dados
determina uma nova permisso de escrita em PC, chamada PCEn, que est a TRUE se o PCWrite
acedido ou quando ambos os Branch e Zero so acedidos.
562
Isto completa o projeto do caminho de dados dos processadores multi-ciclo MIPS. O processo de
projeto muito semelhante ao dos processadores de ciclo-nico em que o hardware
sistematicamente ligado entre os elementos de estado para manipular cada uma das instrues. A
diferena que a instruo executada em diferentes passos consecutivos. Registros no
arquiteturais so introduzidos para armazenar os resultados dos diferentes passos. Deste modo, a
ALU pode ser reutilizada permitindo economizar o custo de somadores extra. Do mesmo modo,
instrues e dados podem ser armazenados numa memria partilhada. Na prxima seo
desenvolvemos o controlador de uma FSM que devolve a sequncia apropriada de sinais de controlo
ao caminho de dados em cada passo de execuo de uma instruo.
7.4.2. Controlo Multi-ciclo
Como no processador de ciclo-nico, a unidade de controle determina os sinais de controle com
base nos campos opcode e funct da instruo, Instr31:26 e Instr5:0. A Figura 7.27 apresenta todo o
processador multi-ciclo MIPS com a unidade de controlo ligado ao caminho de dados. O caminho de
dados mostrado em preto, e a unidade de controle mostrado em azul.
Como no processador de ciclo-nico, a unidade de controlo dividida num controlador principal e
num decodificador ALU, como mostrado na Figura 7.28. O decodificador ALU mantm-se inalterada
e segue a tabela verdade da Tabela 7.2. Agora, no entanto, o controlador principal uma FSM que
aplica os sinais de controlo adequados sobre aos ciclos ou passos. A sequncia de sinais de controlo
563
depende da instruo a ser executada. No restante desta seo, iremos desenvolver o diagrama de
transio de estado da FSM para o controlador principal.
Figura 7.27 Processador multi-ciclo completo
O controlador principal produz os sinais de seleo do multiplexador e de ativao dos registros para
o caminho de dados. Os sinais de seleo so MemtoReg, RegDst, IorD, PCSrc, ALUSrcB e ALUSrcA. Os
sinais de ativao so IRWrite, Mem-Write, PCWrite, Branch, e RegWrite.
Para manter os diagramas de transio de estado legveis, apenas os sinais de controlo relevantes
so listados. Os sinais de seleo so listados apenas quando so relevantes; caso contrrio, so no
relevantes. Os sinais de ativao so listados apenas quando eles so acedidos; Caso contrrio, so 0.
564
Figura 7.28 Estrutura interna da unidade de controlo
O primeiro passo para qualquer instruo obter a instruo da memria no endereo contido
no PC. A FSM entra neste estado aps reset. Para ler a memria, IorD = 0, de modo que o endereo
tomado a partir do PC. IRWrite ativado para escrever a instruo no registro de instruo, IR.
Enquanto isso, o PC deve ser incrementado de 4 para apontar para a prxima instruo. Porque a
ALU no est a ser usada para qualquer outra coisa, o processador pode us-la para calcular PC + 4,
ao mesmo tempo que se obtm a instruo. ALUSrcA = 0, ento SrcA vem do PC. ALUSrcB = 01, ento
SrcB a constante 4. ALUOp = 00, ento o decodificador da ALU produz ALUControl = 010 para fazer
a ALU adicionar. Para atualizar o PC com este novo valor, PCSrc = 0, e PCWrite ativado. Estes sinais
de controlo so apresentados na Figura 7.29. O fluxo de dados neste passo mostrado na Figura
7.30, com a obteno de instrues demonstrada utilizando a linha tracejada azul e o incremento do
PC demonstrado utilizando a linha tracejada cinzento. Figura 7.29 Obter a instruo (fetch)
O prximo passo ler o banco de registros e decodificar a instruo. O banco de registros l

sempre as duas fontes especificadas pelos campos rs e rt da instruo. Enquanto isso, o sinal do
imediato. A descodificao envolve examinar o opcode da instruo para determinar o que fazer a
seguir. No so necessrios sinais de controlo para descodificar a instruo, mas a FSM deve esperar
565
um ciclo para que a leitura e a descodificao se completem, conforme mostrado na Figura 7.31. O
novo estado destacada em azul. O fluxo de dados mostrado na Figura 7.32.
Figura 7.30 Fluxo de dados no decorrer do passo de obteno da instruo
Figura 7.31 Descodificao
566
Figura 7.32 Fluxo de dados no decorrer do passo de descodificao
Agora a FSM prossegue para um dos vrios estados possveis, dependendo do opcode. Se a
instruo um carregamento de ou para a memria (lw ou sw), o processador multi-ciclo
determina o endereo adicionando o endereo base ao imediato com sinal estendido. Isso requer
que ALUSrcA = 1 para seleccionar o registro A e que ALUSrcB = 10 para seleccionar SignImm. ALUOp
= 00, assim a ALU adiciona. O endereo efectivo armazenado no registro ALUOut para uso no
passo seguinte. Este passo da FSM mostrado na Figura 7.33, e o fluxo de dados mostrado na
Figura 7.34.
Se a instruo lw, o processador multi-ciclo deve de seguida ler os dados da memria e

escrev-los para o banco de registros. Estes dois passos so mostrados na Figura 7.35. Para ler a
partir da memria, IorD = 1 para seleccionar o endereo de memria que acabou de ser
determinado e guardado em ALUOut. Este endereo na memria lido e guardado no registro de
dados durante o estgio S3. No prximo estgio, S4, os dados so gravados no banco de registros.
567
MemtoReg = 1 para selecionar Data, e RegDst = 0 para puxar o registro de destino do campo rt da
instruo. RegWrite activado para executar a gravao, completando a instruo lw. Finalmente, a
FSM retorna ao estado inicial, S0, para obter a prxima instruo. Para este e subsequentes estgios,
tente visualizar o fluxo de dados sozinho.
Do estado S2, se a instruo for sw, os dados lidos a partir da segunda porta do banco de registros
so simplesmente escritos na memria. No S3 estado, IorD = 1 para selecionar o endereo calculado
em S2 e guardados em ALUOut. MemWrite ativado para escrever na memria. Novamente, a FSM
volta a S0 para obter a prxima instruo. O passo acrescentado mostrado na Figura 7.36.
Figura 7.33 Determinao do endereo de memria
568
Figura 7.34 Fluxo de dados no decorre da determinao do endereo de memria
Se o opcode indica uma instruo do tipo-R, o processador multi-ciclo deve determinar o

resultado usando a ALU e escrever esse resultado para no banco de registros. A Figura 7.37 apresenta
estes dois passos. Em S6, a instruo executada atravs da seleco dos registros A e B (ALUSrcA =
1, ALUSrcB = 00) e realizando a operao da ALU indicada pelo campo funct da instruo. ALUOp =
10 para todas as instrues do tipo-R. O ALUResult armazenado em ALUOut. Em S7, ALUOut
gravado no banco de registros, RegDst = 1, porque o registro de destino especificado no campo rd
da instruo. MemtoReg = 0 porque os dados de gravao, WD3, vem de ALUOut. RegWrite activado
para gravar o banco e registros.
Para uma instruo beq, o processador deve determinar o endereo de destino e comparar os dois
registros fonte para determinar se o branch deve ser realizado. Isto requer dois usos da ALU e,
portanto, pode exigir dois novos estados. Observe, no entanto, que a ALU no foi usada durante S1
569
quando os registros estavam a ser lido. O processador pode tambm usar a ALU nessa altura para
calcular o endereo de destino, adicionando ao PC incrementado, PC + 4, para SignImm 4, como
mostrado na Figura 7.38. ALUSrcA = 0 para selecionar o PC incrementado, ALUSrcB = 11 para
selecionar SignImm 4, e ALUOp = 00 para somar. O endereo de destino armazenado em ALUOut.
Se a instruo no beq, o endereo calculado no ser utilizado nos ciclos subsequentes, mas a sua
computao foi inofensiva. Em S8, o processador compara os dois registros, subtraindo-os e
verificando se o resultado 0. Se assim for, o processador passa para o endereo que acabou de ser
determinado. ALUSrcA = 1 para selecionar o registro A; ALUSrcB = 00 para selecionar o registro B;
ALUOp = 01 para subtrair; PCSrc = 1 para tomar o endereo de destino de ALUOut e Branch = 1 para
atualizar o PC com este endereo se o resultado da ALU de 0.
Figura 7.35 Leitura da memria

570
Colocando estes passos juntos, a Figura 7.39 mostra o diagrama de transio de estado completo
para o controlador principal do processador multi-ciclo. Converter em hardware uma tarefa
simples, mas tediosa usando as tcnicas do Captulo 3. Melhor ainda, a FSM pode ser codificada em
um HDL e sintetizada utilizando as tcnicas do Captulo 4.
Figura 7.36 Escrita da memria
571
Figura 7.37 Execuo de uma operao do tipo-R
572

Como fizemos na Seo 7.3.3 para o processador de ciclo-nico, vamos agora estender o
processador multi-ciclo para suportar as instrues Addi e j. Os dois exemplos seguintes ilustram o
processo de projeto geral para suportar as novas instrues.
Exemplo 7.5 INSTRUO ADDI
Modificar o processador multi-ciclo para suportar addi.
Figura 7.38 Branch
573
Soluo: O caminho de dados j capaz de adicionar registros a imediatos, ento tudo o que
precisamos fazer adicionar novos estados FSM do controlador principal para addi, como
mostrado na Figura 7.41. Os estados so semelhantes aos das instrues do tipo-R. Em S9, o registro
A adicionado a SignImm (ALUSrcA = 1, ALUSrcB = 10, ALUOp = 00) e o resultado, ALUResult,
armazenado em ALUOut. Em S10, ALUOut escrito no registro especificado pelo campo de rt da
instruo (RegDst = 0, MemtoReg = 0, RegWrite so activados). O leitor astuto pode perceber que S2
e S9 so idnticos e podem ser fundidos num nico estado.
Exemplo 7.6 INSTRUO J
Modificar o processador multi-ciclo para suportar j.

Soluo: Em primeiro lugar, temos de modificar o caminho de dados para calcular o prximo valor do
PC, no caso de uma instruo j. Em seguida, devemos adicionar um estado ao controlador principal
para lidar com a instruo.
A Figura 7.42 mostra o caminho de dados melhorado. O endereo de destino do salto formado
deslocando para a esquerda por dois o campo de endereo addr de 26-bits da instruo, em seguida,
antecedendo os quatro bits mais significativos da PC j incrementado. O multiplexador PCSrc ser
estendido para ocupar esse endereo como uma terceira entrada.
A Figura 7.43 mostra o controlador principal melhorado. O novo estado, S11, simplesmente
seleciona o PC' como o valor PCJump (PCSrc = 10) e escreve no PC. Note-se que o sinal de seleo
PCSrc alargado para dois bits tambm em S0 e S8.
574
Figura 7.39 SFM de controlo multi-ciclo

O tempo de execuo de uma instruo depende tanto do nmero de ciclos que ela utiliza como do
tempo de ciclo. Considerando que o processador de ciclo-nico realiza todas as instrues num ciclo,
o processador multi-ciclo utiliza nmeros variveis de ciclos para as vrias instrues. No entanto, o
processador multi-ciclo faz menos trabalho por ciclo e, assim, tem um tempo de ciclo mais curto.
O processador multi-ciclo requer trs ciclos para as instrues beq e j, quatro ciclos para sw,
addi, e instrues do tipo-R, e cinco ciclos para instrues lw. O CPI depende da probabilidade
relativa de que cada instruo seja usada.
575
Figura 7.40 Estados do controlador principal para addi
Exemplo 7.7 CPI DO PROCESSADOR MULTI-CICLO

O benchmark SPECint2000 consiste em aproximadamente 25% cargas, 10% armazenamentos, 11%
branchs, 2% jumps, e 52% de instrues do tipo-R. Determine o CPI mdio para este benchmark.
Soluo: O CPI mdio a soma ao longo de cada instruo do CPI para cada instruo multiplicado
pela fraco de tempo que a instruo usada. Para este valor de referncia, o CPI = mdia (0,11 +
0,02) (3) + (0,52 + 0,10) (4) + (0.25) (5) = 4,12. Isto melhor que o pior caso de CPI de 5, o que seria
exigido se todas as instrues levassem o mesmo tempo.
576
Figura 7.41 Caminho de dados MIPS multi-ciclo melhorado para suportar a instruo j
Lembre-se que projetmos o processador multi-ciclo de modo que cada ciclo envolvia uma
operao da ALU, acesso memria, ou acesso ao banco de registros. Vamos supor que o banco de
registros mais rpido do que a memria e que a escrita de memria mais rpida do que a leitura
de memria. Uma anlise ao caminho de dados revela dois possveis caminhos crticos que limitam o
tempo de ciclo:
= + + max( + , ) + (7.4)
Os valores numricos destes tempos dependem da tecnologia de implementao especfica.
577
Exemplo 7.8 COMPARAO DO DESEMPENHO DO PROCESSADOR

Ben Bitdiddle est se perguntando se seria melhor ele construir o processador multi-ciclo em vez
do processador de ciclo-nico. Para ambos os projetos, ele planeja usar um processo de fabricao
CMOS 65 nm com os atrasos apresentados na Tabela 7.6. Ajude a comparar o tempo de execuo de
cada processador para 100 bilhes de instrues da referncia SPECint2000 (ver Exemplo 7.7).
Figura 7.42 Estado do controlador principal para j
578
Soluo: De acordo com a Equao de 7.4, o tempo de ciclo do processador multi-ciclo Tc2 = 30 +
25 + 250 + 20 = 325 ps. Usando o CPI de 4,12 do Exemplo 7.7, o tempo total de execuo 2 = (100
109 instrues) (4,12 ciclos/instruo) (325 10-12 s/ciclo) = 133,9 segundos. De acordo com o
Exemplo 7.4, o processador de ciclo-nico teve um tempo de ciclo de Tc1 = 925 ps, um CPI de 1, e um
tempo total de execuo de 92,5 segundos.
Uma das motivaes originais para a construo de um processador multi-ciclo evitar que todas
as instrues demorarem tanto tempo como a mais lenta. Infelizmente, este exemplo mostra que o
processador multi-ciclo mais lento do que o processador de ciclo-nico, dadas as premissas do CPI
e os atrasos dos elementos do circuito. O problema fundamental que, embora a instruo mais
lenta, lw, tenha sido dividida em cinco estgios, o tempo de ciclo do processador multi-ciclo no foi
melhorado quase cinco vezes. Isto em parte porque nem todos os passos tm exatamente o mesmo
comprimento, e em parte porque a sobrecarga de sequenciamento de 50 ps e o tempo de setup
devem agora ser pago a cada passo, no apenas uma s vez para toda a instruo. Em geral, os
engenheiros tm aprendido que difcil explorar o fato de que alguns clculos so mais rpidos do
que outros, a menos que as diferenas sejam grandes.
Comparando com o processador de ciclo-nico, o processador multi-ciclo provvel que seja
menos dispendioso, pois elimina dois somadores e combina as memrias de dados e de instrues
numa nica unidade. Ele, no entanto, exigem cinco registros no arquiteturais e multiplexadores
adicionais.
7.5. PROCESSADOR COM PIPEPLINE

O pipeline, introduzido na Seo 3.6, uma forma poderosa de melhorar a taxa de transferncia
de um sistema digital. Projetamos um processador com pipeline, subdividindo o processador de ciclo-
nico em cinco estgios de pipeline. Assim, cinco instrues podem ser executadas simultaneamente,
uma em cada estgio. Uma vez que cada estgio tem apenas um quinto de toda a lgica, a frequncia
do relgio quase cinco vezes mais rpida. Logo, a latncia de cada instruo idealmente
inalterada, mas o rendimento idealmente cinco vezes melhor. Os microprocessadores executam
milhes ou bilhes de instrues por segundo, de modo que o rendimento mais importante do que
579
a latncia. O pipelining introduz alguma sobrecarga, de modo que o rendimento no ser to elevado
como poderamos idealmente desejar, mas o pipelining, no entanto, proporciona uma tal vantagem,
com um custo reduzido, que todos os modernos microprocessadores de alto desempenho possuem
um pipeline.
Ler e escrever na memria e no banco de registros e usar a ALU normalmente constitui um dos
maiores atrasos no processador. Escolhemos um pipeline de cinco estgios para que cada estgio
envolva exatamente um desses passos lentos. Especificamente, chamamos os cinco estgios fetch,
descodificar, executar, memria e writeback. Eles so semelhantes aos cinco passos que o
processador multi-ciclo utiliza para executar lw. No estgio de fetch, o processador l as instrues
a partir da memria de instrues. No estgio de decodificao, o processador l os operandos do
banco de registros de origem e decodifica a instruo para produzir os sinais de controle. No estgio
de execuo, o processador executa um clculo com a ALU. No estgio de memria, o processador l
ou escreve na memria de dados. Finalmente, no estgio de writeback, o processador escreve o
resultado para o banco de registros, quando aplicvel.
A Figura 7.43 mostra um diagrama de tempo comparando o processado de ciclo-nico com o
processador com pipeline. O tempo est, no eixo horizontal, e as instrues esto no eixo vertical. O
diagrama assume os atrasos dos elementos lgicos da Tabela 7.6, mas ignora os atrasos de
multiplexadores e registros. No processador de ciclo-nico, Figura 7.43 (a), a primeira instruo lida
a partir da memria no instante 0; em seguida, os operadores so lidos a partir do banco de registros;
e, em seguida, a ALU executa o clculo necessria. Finalmente, a memria de dados pode ser acedida,
e o resultado escrito de volta para o banco de registros em 950 ps. A segunda instruo comea
quando o primeiro termina. Assim, neste diagrama, o processador de ciclo-nico tem uma latncia
de instruo de 250 + 150 + 200 + 250 + 100 = 950 ps e um caudal de 1 instruo por 950 ps (1,05
bilhes de instrues por segundo).
580
Figura 7.43 Diagrama temporal: (a) processador de ciclo-nico, (b) processador com pipeline
No processador com pipeline, Figura 7.43 (b), o comprimento de um estgio do pipeline de 250
ps definida pelo estgio mais lento, o acesso memria (nos estgios de fetch ou memria). No
instante 0, a primeira instruo obtida a partir da memria. Aps 250 ps, a primeira instruo entra
no estgio de decodificao, e a segunda instruo obtida (fetched). Aps 500 ps, a primeira
instruo executada, a segunda instruo entra no estgio de decodificao, e uma terceira
instruo obtida. E assim por diante, at que todas as instrues so terminadas. A latncia de
instruo de 5 250 = 1.250 ps. A taxa de transferncia de 1 instruo por 250 ps (4 bilhes de
instrues por segundo). Uma vez que os estgios no so perfeitamente equilibrados com
quantidades iguais de lgica, a latncia ligeiramente mais longa para o processador com pipeline
de que o de ciclo-nico. Da mesma forma, a taxa de transferncia no cinco vezes maior para um
pipeline de cinco estgios como para o processador de ciclo-nico. No entanto, a vantagem de
transferncia substancial.
581
Figura 7.44 Viso abstrata da operao do pipeline
A Figura 7.44 fornece uma viso abstrata do pipeline em operao, na qual cada estgio
representado pictoricamente. Cada estgio do pipeline representado com os seus componentes
principais - memria de instruo (IM), leitura do banco de registros (RF), execuo na ALU, memria
de dados (DM), e writeback no banco de registros - para ilustrar o fluxo de instrues atravs do
pipeline. A leitura atravs de uma linha mostra os ciclos de relgio em que uma instruo especfica
est em cada estgio. Por exemplo, a instruo sub obtida no ciclo 3 e executada no ciclo 5. Lendo
para baixo numa coluna mostra o que os vrios estgios do pipeline esto fazendo num determinado
ciclo. Por exemplo, no ciclo 6, a instruo or obtida da memria de instrues, enquanto $s1 est
a ser lido a partir do banco de registros, a ALU est computa $T5 and $t6, a memria de dados
est ociosa, e o banco de registros est a escrever uma soma para $s3. Os estgios esto sombreados
para indicar quando so utilizados. Por exemplo, a memria de dados utilizada por lw no ciclo 4 e
por sw no ciclo 8. A memria de instrues e a ALU so utilizadas em todos os ciclos. O banco de
registros escrito por todas as instrues, exceto sw. No processador com pipeline, o banco de
registros escrito na primeira parte de um ciclo e lido na segunda parte, tal como sugerido pelo
sombreamento. Desta forma, os dados podem ser lidos e escritos de volta dentro de um nico ciclo.
582
Um desafio central em sistemas com pipeline est em lidar com os conflitos (hazards) que ocorrem
quando os resultados de uma instruo so necessrios por uma instruo posterior antes de que
essa instruo esteja concluda. Por exemplo, se o add na Figura 7.44 usa $s2 em vez de $t2, existe
o perigo de que o registro $s2 no tenha sido escrito pelo lw no momento em que lido pelo add.
Esta seo explora o forwarding, stalls, e flushes como mtodos para resolver estes perigos.
Finalmente, esta seo revisita a anlise de desempenho considerando a sobrecarga de
sequenciamento e o impacto de hazards.
7.5.1. Caminho de Dados do Pipeline
O caminho de dados do pipeline formado cortando o caminho de dados de ciclo-nico em cinco
estgios separados por registros do pipeline. A Figura 7.45 (a) mostra o caminho de dados de ciclo-
nico esticado para deixar espao para os registros do pipeline. A Figura 7.45 (b) mostra o caminho
de dados do pipeline formado pela insero de quatro registros de pipeline para separar o caminho
de dados em cinco estgios. Os estgios e os seus limites so indicados em azul. Aos sinais dado um
sufixo (F, D, E, H, ou W) para indicar a fase em que residem.
O banco de registros peculiar porque lido na fase de decodificao e escrito na fase Writeback.
obtido na fase de decodificao, mas o endereo de escrita e os dados vm do estgio Writeback.
Este feedback vai levar a hazards de pipeline, que so discutidas na Seo 7.5.3. O banco de registros
no processador com pipeline, escreve no flanco descendente do CLK, quando WD3 est estvel.
Uma questo subtil, mas crtica em pipelining, que todos os sinais associados a uma instruo
em particular devem avanar atravs do pipeline em unssono. A Figura 7.45 (b) tem um erro
relacionado com esta questo. O leitor consegue encontr-lo?
O erro est na lgica de escrita do banco de registros, que deve operar no estgio de Writeback.
Os dados vm de ResultW, um sinal do estgio Writeback. Mas o endereo vem de WriteRegE, um
sinal do estgio executar. No diagrama do pipeline da Figura 7.44, durante o ciclo 5, o resultado da
instruo lw seria escrito incorretamente para $S4, em vez de $s2.
583
A Figura 7.46 apresenta um caminho de dados corrigido. O sinal WriteReg agora canalizado ao
longo dos estgios de Memria e Writeback, por isso permanece em sincronia com o resto da
instruo. WriteRegW e ResultW so alimentados de volta em conjunto para o banco de registros no
estgio de Writeback.
O leitor astuto pode perceber que a lgica do PC' tambm problemtica, porque pode ser
atualizada com um sinal dos estgios de memria ou de fetch (PCPlus4F ou PCBranchM). Este hazard
de controle ser resolvido no Seo 7.5.3.
Figura 7.45 Caminho de dados de ciclo-nico e de pipeline

584
7.5.2. Controlo do Pipeline

O processador com pipeline toma os mesmos sinais de controle que o processador de ciclo-nico
e, portanto, usa a mesma unidade de controle. A unidad e de controlo examina os campos
opcode e funct da instruo no estgio de decodificao para produzir os sinais de controlo, como
foi descrito na Seo 7.3.2. Estes sinais de controle devem ser canalizados em conjunto com os dados
para que eles permaneam sincronizados com a instruo.
O processador com pipeline e controlo mostrado na Figura 7.47. RegWrite deve ser canalizado
para o estgio Writeback antes que seja realimentado para o banco de registros, assim como
WriteReg foi canalizado na Figura 7.46.
Figura 7.46 Caminho de dados corregido
585
Figura 7.47 Processador com pipeline e controlo
7.5.3. Hazards
Num sistema COM pipeline, mltiplas instrues so tratadas simultaneamente. Quando uma
instruo dependente dos resultados de uma outra que ainda no tenha sido completada, ocorre
um hazard.
Figura 7.48 Abstrao do diagrama do pipeline ilustrando hazards
586
O banco de registros pode ser lido e gravado no mesmo ciclo. A gravao ocorre durante a primeira
metade do ciclo e a leitura ocorre durante a segunda metade do ciclo, portanto, um registro pode ser
escrito e lido de volta no mesmo ciclo sem a introduo de um hazard.
A Figura 7.48 ilustra os hazards que ocorrem quando uma instruo escreve um registro ($s0) e
as instrues subsequentes leem esse registro. Isto designado por hazard de leitura seguido de
escrita (RAW ready after writer). A instruo add escreve resultado em $s0 na primeira metade
do ciclo 5. No entanto, a instruo and l $s0 no ciclo 3, obtendo-se um valor errado. A instruo
or l $s0 no ciclo de 4, mais uma vez obtendo o valor errado. A instruo sub l $s0 na segunda
metade do ciclo 5, obtendo-se o valor correto, que foi escrito na primeira metade do ciclo 5. As
instrues subsequentes, leem tambm o valor correto de $s0. O diagrama mostra que os hazards
podem ocorrer neste pipeline quando uma instruo escreve um registro e uma das duas instrues
subsequentes l esse registro. Sem tratamento especial, o pipeline iria calcular o resultado errado.
Uma inspeo mais prxima, no entanto, permite observar que a soma da instruo add
calculado pela ALU no ciclo 3 e no estritamente necessria pela instruo and at que a ALU a usa
no ciclo 4. Em princpio, devemos ser capazes de encaminhar o resultado de uma instruo para outra
para resolver o hazard RAW sem ter que abrandar o pipeline. Noutras situaes exploradas mais
adiante nesta seo, podemos ter que parar o pipeline para dar tempo para que um resultado seja
produzido antes da instruo subsequente utiliza esse resultado. Em qualquer caso, algo deve ser
feito para resolver os hazards de modo que o programa executado corretamente apesar do pipeline.
Os hazards so classificados como de dados ou de controlo. Um hazard de dados ocorre quando
uma instruo tenta ler um registro que ainda no foi escrito por uma instruo anterior. Um hazard
de controle ocorre quando a deciso de qual a prxima instruo no foi tomada no momento em
que o fetch ocorre. No restante desta seo, vamos melhorar o processador com pipeline, com uma
unidade de hazard que detecta riscos e os trata adequadamente, de modo que o processador executa
o programa correctamente.
587
Resolver hazards de dados com encaminhamento

Alguns hazards de dados podem ser resolvidos por meio do encaminhamento (tambm chamado
de bypass) um resultado do estgio de memria ou writeback para uma instruo dependente no
estgio de execuo. Isto requer a adio de multiplexadores na frente da ALU para selecionar o
operando a partir do banco de registros ou dos estgios de memria ou writeback. A Figura 7.49
ilustra esse princpio. No ciclo 4, $s0 encaminhada a partir do estgio de memria da instruo
add para o estgio de execuo da instruo add dependente. No ciclo 5, $s0 encaminhada a
partir do estgio writeback da instruo add para o estgio de execuo instruo or dependente.
O encaminhamento necessrio quando uma instruo no estgio de execuo tem um registro
fonte correspondente ao registrador de destino de uma instruo nos estgios de memria ou
writeback. A Figura 7.50 modifica o processador com pipeline para suportar o encaminhamento. Uma
unidade de deteco de hazard e dois multiplexadores de encaminhamento so adicionados. A
unidade de deteco de hazard recebe os dois registros de origem da instruo na fase de execuo
e os registros de destino das instrues nos estgios de memria e de writeback. Tambm recebe os
sinais RegWrite dos estgios de memria e writeback para saber se o registro de destino vai
realmente ser escrito (por exemplo, as instrues sw e beq no escrevem os resultados no banco de
registros e, portanto, no precisam ter seus resultados encaminhados). Note-se que os sinais
RegWrite so conectados por nome. Por outras palavras, em vez de atravancar o diagrama com
longos fios correndo a partir dos sinais de controlo na parte superior para a unidade de harzard na
parte inferior, as conexes so indicadas por uma etiqueta marcada com o nome do sinal de controlo
ao qual ele est ligado.
A unidade de deteco de hazards determina os sinais de controle para os multiplexadores de
encaminhamento para escolher os operandos do banco de registros ou a partir dos resultados no
estgio de memria ou de writeback. Deve encaminhar a partir de um estgio, se esse estgio vai
escrever num registro de destino e o registro de destino corresponde ao registro de origem. No
entanto, $0 programado para 0 e nunca deve ser encaminhada. Se tanto os estgios de memria e
de writeback contm registros de destino correspondentes, o estgio de memria deve ter
588
prioridade, pois contm a instruo mais recentemente executada. Em resumo, a funo da lgica
de encaminhamento para SrcA dada abaixo. A lgica de encaminhamento para SrcB (ForwardBE)
idntica, excepto que verifica rt em vez de rs.
if ((rsE != 0) AND (rsE == WriteRegM) AND RegWriteM) then
ForwardAE = 10
else if ((rsE != 0) AND (rsE == WriteRegW) AND RegWriteW) then
ForwardAE = 01
else ForwardAE = 00
Figura 7.49 Abstrao do diagrama do pipeline ilustrando o encaminhamento
589
Figura 7.50 Processador com pipeline com encaminhamento para resolver hazards
590
Resolver hazards de dados com stalls

O encaminhamento suficiente para resolver os hazards de dados RAW quando o resultado
calculado no estgio de execuo de uma instruo, porque o seu resultado pode ento ser
encaminhado para o estgio de execuo da prxima instruo. Infelizmente, a instruo lw no
termina a leitura de dados at o final do estgio de memria, portanto, o seu resultado no pode ser
encaminhado para o estgio de execuo da prxima instruo. Dizemos que a instruo lw tem uma
latncia de dois ciclos, pois uma instruo dependente no pode usar o seu resultado at dois ciclos
mais tarde. A Figura 7.51 apresenta este problema. A instruo lw recebe dados da memria no final
do ciclo 4. Mas a instruo and precisa dos dados como operandos de origem no incio do ciclo 4. No
h forma de resolver este hazard com encaminhamento.
Figura 7.51 Abstrao do diagrama do pipeline ilustrando os problemas de encaminhamento com

lw
A soluo alternativa parar o pipeline, segurando a operao at que os dados fiquem disponveis.
A Figura 7.52 mostra o stall da instruo dependente (and) no estgio de descodificao. O and entra
no estgio de descodificao no ciclo 3 onde o stall ocorre atravs do ciclo 4. A instruo seguinte (or)
deve tambm permanecer no estgio de fetch durante ambos os ciclos, porque o estgio descodificao
est cheio.
591
No ciclo 5, o resultado pode ser encaminhado a partir do estgio writeback de lw para o estgio
de execuo de and. No ciclo 5, a fonte $s0 da instruo or lida diretamente do banco de
registros, sem a necessidade de encaminhamento.
Observe que o estgio de execuo no utilizado no ciclo 4. Da mesma forma, o estgio de
memria no utilizado no ciclo 5 e o de writeback no utilizado no ciclo 6. propagao de
estgios utilizados atravs do pipeline chama-se bolha, e comporta-se como uma instruo nop. A
bolha introduzida zerando os sinais do estgio de execuo durante o stall do estado de
descodificao para que a bolha no execute uma ao e altere o estado arquitetnico.
Em resumo, a paragem de um estgio realizada, desativando o registro pipeline, de modo que o
contedo no seja alterado. Quando um estgio parado, todas os estgios anteriores tambm
devem so parados, de modo que no haja instrues subsequentes perdidas. O registro de pipeline
diretamente aps paragem do estgio deve ser limpo para evitar a propagao para a frente de
informao falsa. O stall degrada o desempenho, de modo que s deve ser usado quando necessrio.
A Figura 7.53 modifica o processador com pipeline, para adicionar stalls para a dependncia de
dados de lw. A unidade de hazards examina a instruo no estgio de execuo. Se for lw e se o seu
registro de destino (rtE) corresponde a qualquer operando fonte da instruo no estgio de
descodificao (rsD ou rtD), essa instruo deve ser bloqueada no estgio de descodificao at
que o operando fonte esteja pronto.
Figura 7.52 Abstrao do diagrama do pipeline ilustrando stall para resolver hazards
592
Figura 7.53 Processador com pipeline com stalls para resolver o hazard de dados
593
Os stalls so suportados pela adio de entradas (EN) aos registros de fetch e descodificao do
pipeline e uma entrada de reset sncrono/clear (CLR) ao registro de execuo do pipeline. Quando um
stall de lw ocorre, StallD e StallF so ativados para forar os registros dos estgios de descodificao
e de fetch do pipeline a manter os seus valores antigos. FlushE tambm ativado para limpar o
contedo do registro de estgio de execuo do pipeline, introduzindo uma bolha.
O sinal MemtoReg ativado pela instruo lw. Assim, a lgica para computar os stalls e flushes
lwstall = ((rsD== rtE) OR (rtD== rtE)) AND MemtoRegE
StallF = StallD = FlushE = lwstall
Resolver Hazards de Controlo
A instruo beq apresenta um hazard de controle: o processador com pipeline no sabe que
instruo obter em seguida, porque a deciso branch no foi ainda tomada no momento em que o
fetch da prxima instruo realizado.
Um mecanismo para lidar com o hazard de controle parar o pipeline at que a deciso de branch
seja tomada (isto , PCSrc seja computado). Porque a deciso tomada no estgio de memria, o
pipeline teria de ser parado por trs ciclos a cada branch. Isto iria degradar severamente o
desempenho do sistema.
Uma alternativa consiste em prever se o branch ser realizado e comear a executar as instrues
baseadas na previso. Uma vez que a deciso de branch esteja disponvel, o processador pode jogar
fora as instrues se a previso estava errada. Em particular, suponha que prevemos que o branch
no ser realizado e simplesmente continuamos a executar o programa em sequncia. Se o branch
for realizado, as trs instrues a seguir ao branch devem ser descartadas, limpando os registros de
pipeline para essas instrues. Estes ciclos de instruo desperdiados so chamados de branch
misprediction penalty.
A Figura 7.54 mostra um esquema deste tipo, em que um branch do endereo 20 para 64
executado. A deciso de branch no tomada at ao ciclo 4, pelo que as instrues and, or, e sub
594
nos endereos 24, 28 e 2C j tenham sido lidas. Estas instrues devem ser descartadas, e a instruo
slt obtida do endereo 64 no ciclo 5. Isto uma melhoria, mas descartando assim tantas instrues
quando o branch executado ainda degrada a performance.
Poderamos reduzir a branch misprediction penalty se a deciso fosse feita mais cedo. Tomar a
deciso requer simplesmente comparar os valores de dois registros. Usando um comparador
igualdade dedicado muito mais rpido do que realizar uma subtrao e deteco de zero. Se o
comparador suficientemente rpido, poderia ser movida para trs para o estgio de descodificao,
de modo que os operandos sejam lidos do banco de registros e comparados para determinar o
prximo PC at ao final da fase de descodificao.
A Figura 7.55 ilustra o funcionamento do pipeline com a previso de branch a ser tomada no ciclo
2. No ciclo 3, a instruo and descartada e a instruo slt obtida. Agora a branch misprediction
penalty reduzida para apenas uma instruo, em vez de trs.
Figura 7.54 Abstrao do diagrama do pipeline ilustrando o flushing quando um branch

executado
595
Figura 7.55 Abstrao do diagrama do pipeline ilustrando a antecipao da tomada de deciso de

um branch
A Figura 7.56 modifica o processador com pipeline, para mover a deciso de branch para mais cedo
e lidar com hazards de controle. Um comparador de igualdade adicionado ao estgio de
descodificao e a porta AND PCSrc antecipada, de modo que PCSrc pode ser determinado no
estgio de descodificao em vez de no estgio de memria. O somador PCBranch tambm deve ser
levado para o estgio de decodificao de modo a que o endereo de destino possa ser calculado a
tempo. A entrada limpeza sncrona (CLR) conectada a PCSrcD adicionada ao registro de pipeline do
estgio de descodificao para que a instruo obtida incorretamente possa ser descartada quando
um branch executado.
Infelizmente, o hardware de antecipao da deciso de branch introduz um novo hazard de dados
RAW. Especificamente, se um dos operandos de origem para o branch foi calculado por uma instruo
anterior e ainda no foi gravado no banco de registros, o branch ir ler o valor do operando errado a
partir do banco de registros. Como antes, podemos resolver o hazard de dados, enviando o valor
correto se estiver disponvel, ou atrasando o pipeline at que os dados estejam disponveis.
A Figura 7.57 mostra as modificaes necessrias para o processador com pipeline lidar com a
dependncia dos dados no estgio de descodificao. Se existir um resultado no estgio writeback,
596
ser escrito na primeira metade do ciclo e lido durante a segunda parte do ciclo, por isso no existe
nenhum hazard. Se o resultado de uma instruo na ALU est no estgio de memria, pode ser
encaminhado para o comparador de igualdade atravs de dois novos multiplexadores. Se o resultado
de uma instruo na ALU est no estgio de execuo ou o resultado de uma instruo lw est no
estgio de memria, o pipeline tem de ser imobilizado no estgio de descodificao at que o
resultado esteja pronto.
A funo da lgica de encaminhamento do estgio de descodificao dada abaixo.
ForwardAD = (rsD != 0) AND (rsD == WriteRegM) AND RegWriteM
ForwardBD = (rtD != 0) AND (rtD == WriteRegM) AND RegWriteM
A funo da lgica de deteco de stall para um branch dada abaixo. O processador deve tomar
uma deciso de branch no estgio de descodificao. Se as fontes do branch dependem de uma
instruo na ALU no estgio de execuo ou de uma instruo lw na fase de memria, o processador
deve esperar que as fontes estejam disponveis.
branchstall =
BranchD AND RegWriteE AND (WriteRegE == rsD OR WriteRegE == rtD)
OR
BranchD AND MemtoRegM AND (WriteRegM == rsD OR WriteRegM == rtD)
Agora, o processador pode parar devido a um hazard de carga ou de branch:
StallF = StallD = FlushE = lwstall OR branchstall
597
Figura 7.56 Processador com pipeline com controlo de hazard de branch
598
Figura 7.57 Processador com pipeline lida com a dependncia dos dados nas instrues de branch
599
Sumrio de Hazards
Em resumo, os hazards de dados RAW ocorrem quando uma instruo depende do resultado de
uma outra instruo que ainda no foi escrita no banco de registros. Os hazards de dados podem ser
resolvidos por encaminhamento se o resultado calculado em breve; caso contrrio, eles exigem a
paragem do pipeline at que o resultado esteja disponvel. Os hazards de controle ocorrem quando a
deciso de qual a instruo a obter ainda no foi tomada no momento em que a prxima instruo
deve ser obtida. Os hazards de controlo so resolvidos com a previso de qual a instruo a ser obtida
e o esvaziamento do pipeline se a previso estiver errada. Antecipando a deciso o mais cedo possvel,
minimiza o nmero de instrues que so descartadas num erro de previso. O leitor pode ter
observado at agora que um dos desafios de projetar um processador com pipeline entender todas
as possveis interaes entre as instrues e descobrir todos os harzards que possam existir. A Figura
7.58 mostra a tratamento completo de hazards por processador com pipeline.
O suporte de novas instrues pelo processador com pipeline, muito parecido com o suporte no
processador de ciclo-nico. No entanto, as novas instrues podem introduzir hazards que devem ser
detectados e resolvidos.
Em particular, o suporte de instrues addi e j no processador com pipeline requer a melhoria

do controlador, exatamente como foi descrito na Seo 7.3.3, e a adio de um multiplexador de jump
ao caminho de dados a seguir ao multiplexador de branch. Como um branch, o jump ocorre no estgio
de descodificao, logo, a instruo seguinte na fase de fetch deve ser descartada. O projeto desta
lgica de descarte deixado para o Exerccio 7.35.
O processador com pipeline, idealmente teria um CPI de 1, porque uma nova instruo obtida a
cada ciclo. No entanto, um stall ou um flush desperdia um ciclo, de modo que o CPI um pouco
maior e depende do programa especfico a ser executado.
600
Exemplo 7.9 CPI DO PROCESSADOR COM PIPELINE

O benchmark SPECint2000 considerado no Exemplo 7.7 composto de aproximadamente 25%
cargas, 10% armazenamentos, 11% branch, 2% jumps, e 52% instrues do tipo-R. Suponha que 40%
das cargas so imediatamente seguidas por uma instruo que usa o resultado, exigindo um stall, e
que um quarto dos branchs so erradamente previstos, exigindo um flush. Suponha que os jumps
sempre descartam as instrues subsequentes. Ignorar outros harzards. Calcular o CPI mdio do
processador com pipeline.
Soluo: O CPI mdio a soma ao longo de cada instruo do CPI para essa instruo multiplicada
pela frao de tempo em que a instruo usada. As cargas requerem um ciclo de relgio quando
no h nenhuma dependncia e dois ciclos, quando o processador deve imobilizar-se durante uma
dependncia, de modo que tm um CPI de (0,6) (1) + (0,4) (2) = 1,4. Os branchs requerem um ciclo de
relgio quando eles so previstos corretamente e dois quando no so, por isso, tm um CPI de (0,75)
(1) + (0,25) (2) = 1,25. Os jumps tm sempre um CPI de 2. Todas as outras instrues tm um CPI de
1. Assim, para este benchmark, o CPI mdio = (0,25) (1,4) + (0,1) (1) + (0,11) (1,25) + (0,02) (2) + (0.52)
(1) = 1,15.
601
Figura 7.58 Processador com pipeline com tratamento completo de hazards
602
Podemos determinar o tempo de ciclo, considerando o caminho crtico em cada um dos cinco
estgios do pipeline mostrados na Figura 7.58. Lembre-se que o banco de registros escrito na
primeira metade do ciclo writeback e lido na segunda metade do estgio de descodificao. Portanto,
o tempo de ciclo dos estgios de descodificao e de writeback duas vezes o tempo necessrio para
fazer o meio ciclo de trabalho.
+ +

2( + + + + + )
= max + + + + (7.5)
+ +
( 2( + + ) )
Exemplo 7.10 COMPARAO DO DESEMPENHO DE PROCESSADORES

Ben Bitdiddle precisa comparar o desempenho do processador com pipeline com os processadores
de ciclo-nico e multi-ciclo considerados no Exemplo 7.8. A maioria dos atrasos lgicas foram
fornecidos na Tabela 7.6. Os outros atrasos dos elementos so de 40 ps para um comparador de
igualdade, de 15 ps para uma porta AND, 100 ps para uma escrita no banco de registros, e 220 ps
para uma escrita na memria. Ajude o Ben a comparar o tempo de execuo de 100 bilhes de
instrues utilizando o benchmark SPECint2000 para cada processador.
Soluo: De acordo com a Equao de 7.5, o tempo de ciclo do processador com pipeline Tc3 = max
[30 + 250 + 20, 2 (150 + 25 + 40 + 15 + 25 + 20), 30 + 25 + 25 + 200 + 20, 30 + 220 + 20, 2 (30 + 25 +
100)] = 550 ps. De acordo com a Equao 7.1, o tempo total de execuo T3 = (100 109 instrues)
(1,15 ciclos / instruo) (550 10-12 s / ciclo) = 63,3 segundos. Isso se compara a 92,5 segundos para
o processador de ciclo-nico e 133,9 segundos para o processador multi-ciclo.
O processador com pipeline substancialmente mais rpido do que os outros. No entanto, a sua
vantagem sobre o processador de ciclo-nico no fica perto do aumento de velocidade em cinco
vezes como seria de esperar de um pipeline de cinco estgios. Os hazards de pipeline introduzem
603
uma pequena penalidade CPI. Mais significativamente, a sobrecarga de sequenciamento dos registros
aplica-se a cada estgio do pipeline, no apenas uma vez para o caminho de dados em geral. A
sobrecarga de sequenciamento limita os benefcios que se podem esperar alcanar com o pipelining.
O leitor atento pode observar que o estgio de decodificao substancialmente mais lento do
que os outros, porque a leitura do banco de registros e a comparao do branch devem ambos
acontecer na metade de um ciclo. Talvez movendo a comparao do branch para o estgio de
decodificao no seja uma boa ideia. Se os branchs em alternativa forem resolvidos no estgio de
execuo, o CPI iria aumentar ligeiramente, porque um erro de previso iria descartar duas instrues,
mas o tempo de ciclo diminuiria substancialmente, dando um aumento de velocidade total.
O processador com pipeline similar em requisitos de hardware ao processador de ciclo-nico,

mas acrescenta um nmero significativo de registros de pipeline, juntamente com multiplexadores e
lgica de controle para resolver hazards.
7.6. REPRESENTAO HDL*

Esta seo apresenta o cdigo HDL para o processador MIPS de ciclo-nico suportando todas as
instrues discutidas neste Captulo, incluindo addi e j. O cdigo ilustra as boas prticas de
codificao para um sistema moderadamente complexa. O cdigo HDL para o processador multi-ciclo
e o processador com pipeline, so deixados para os Exerccio 7.25 e Exerccio 7.40.
Nesta seo, as memrias de instrues e de dados so separadas do processador principal e
ligadas por barramentos de endereos e de dados. Isto mais realista, porque a maioria dos
processadores reais tm memria externa. Tambm ilustra como o processador pode comunicar com
o mundo exterior.
O processador composto por um caminho de dados e um controlador. O controlador, por sua
vez, composto por o decodificador principal e o decodificador da ALU. A Figura 7.59 apresenta um
diagrama de blocos do processador MIPS de ciclo-nico ligado a memrias externas.
604
O cdigo HDL dividido em vrias sees. A seo 7.6.1 fornece o HDL para o caminho de dados
do processador de ciclo-nico e controlador. A seo 7.6.2 apresenta os mdulos genricos, como os
registros e os multiplexadores, que so usados por qualquer microarquitetura. A seo 7.6.3 introduz
o testbench e as memrias externas. O HDL est disponvel em formato electrnico no site do livro
(veja o prefcio).
Figura 7.59 Processador MIPS de ciclo-nico ligado a memria externa
7.6.1. Processador de ciclo-nico

Os mdulos principais do processador MIPS de ciclo-nico so dados nos seguintes exemplos HDL.
605
Exemplo HDL 7.1 MICROPROCESSADOR MIPS DE CICLO-NICO
SystemVerilog VHDL

module mips(input logic clk, reset,
output logic [31:0] pc, entity mips is single cycle MIPS processor
input logic [31:0] instr, port(clk, reset: in STD_LOGIC;
output logic memwrite, pc: out STD_LOGIC_VECTOR(31 downto 0);
output logic [31:0] aluout, writedata, instr: in STD_LOGIC_VECTOR(31 downto 0);
input logic [31:0] readdata); memwrite: out STD_LOGIC;
aluout, writedata: out STD_LOGIC_VECTOR(31 downto 0);
logic memtoreg, alusrc, regdst, readdata: in STD_LOGIC_VECTOR(31 downto 0));
regwrite, jump, pcsrc, zero; end;
logic [2:0] alucontrol;
controller c(instr[31:26], instr[5:0], zero, architecture struct of mips is
memtoreg, memwrite, pcsrc, component controller
alusrc, regdst, regwrite, jump, port(op, funct: in STD_LOGIC_VECTOR(5 downto 0);
alucontrol); zero: in STD_LOGIC;
datapath dp(clk, reset, memtoreg, pcsrc, memtoreg, memwrite: out STD_LOGIC;
alusrc, regdst, regwrite, jump, pcsrc, alusrc: out STD_LOGIC;
alucontrol, regdst, regwrite: out STD_LOGIC;
zero, pc, instr, jump: out STD_LOGIC;
aluout, writedata, readdata); alucontrol: out STD_LOGIC_VECTOR(2 downto 0));
endmodule end component;
component datapath
memtoreg, pcsrc: in STD_LOGIC;
alusrc, regdst: in STD_LOGIC;
regwrite, jump: in STD_LOGIC;
alucontrol: in STD_LOGIC_VECTOR(2 downto 0);
zero: out STD_LOGIC;
pc: buffer STD_LOGIC_VECTOR(31 downto 0);
instr: in STD_LOGIC_VECTOR(31 downto 0);
aluout,writedata: buffer STD_LOGIC_VECTOR(31 downto 0);
readdata: in STD_LOGIC_VECTOR(31 downto 0));
end component;
signal memtoreg, alusrc, regdst, regwrite, jump, pcsrc: STD_LOGIC;
signal zero: STD_LOGIC;
signal alucontrol: STD_LOGIC_VECTOR(2 downto 0);
begin
cont: controller port map(instr(31 downto 26),
instr(5 downto 0), zero, memtoreg,
memwrite, pcsrc, alusrc, regdst,
regwrite, jump, alucontrol);
dp: datapath port map(clk, reset, memtoreg, pcsrc, alusrc,
regdst, regwrite, jump, alucontrol,
zero, pc, instr, aluout, writedata,readdata);
end;
606
Exemplo HDL 7.2 CONTROLADOR
SystemVerilog VHDL
module mips(input logic clk, reset,
module controller(input logic [5:0] op, funct, entity controller is single cycle control decoder
input logic zero, port(op, funct: in STD_LOGIC_VECTOR(5 downto 0);
output logic memtoreg, memwrite, zero: in STD_LOGIC;
output logic pcsrc, alusrc, memtoreg, memwrite: out STD_LOGIC;
output logic regdst, regwrite, pcsrc, alusrc: out STD_LOGIC;
output logic jump, regdst, regwrite: out STD_LOGIC;
output logic [2:0] alucontrol); jump: out STD_LOGIC;
logic [1:0] aluop; alucontrol: out STD_LOGIC_VECTOR(2 downto 0));
logic branch; end;
maindec md(op, memtoreg, memwrite, branch, architecture struct of controller is
alusrc, regdst, regwrite, jump, aluop); component maindec
aludec ad(funct, aluop, alucontrol); port(op: in STD_LOGIC_VECTOR(5 downto 0);
memtoreg, memwrite: out STD_LOGIC;
assign pcsrc = branch & zero; branch, alusrc: out STD_LOGIC;
endmodule regdst, regwrite: out STD_LOGIC;
jump: out STD_LOGIC;
aluop: out STD_LOGIC_VECTOR(1 downto 0));
end component;
component aludec
port(funct: in STD_LOGIC_VECTOR(5 downto 0);
aluop: in STD_LOGIC_VECTOR(1 downto 0);
alucontrol: out STD_LOGIC_VECTOR(2 downto 0));
end component;
signal aluop: STD_LOGIC_VECTOR(1 downto 0);
signal branch: STD_LOGIC;
begin
md: maindec port map(op, memtoreg, memwrite, branch,
alusrc, regdst, regwrite, jump, aluop);
ad: aludec port map(funct, aluop, alucontrol);
pcsrc <= branch and zero;

end;
607
Exemplo HDL 7.3 DECODIFICADOR PRINCIPAL
SystemVerilog VHDL
module maindec(input logic [5:0] op,
output logic memtoreg, memwrite, entity maindec is main control decoder
output logic branch, alusrc, port(op: in STD_LOGIC_VECTOR(5 downto 0);
output logic regdst, regwrite, memtoreg, memwrite: out STD_LOGIC;
output logic jump, branch, alusrc: out STD_LOGIC;
output logic [1:0] aluop); regdst, regwrite: out STD_LOGIC;
logic [8:0] controls; jump: out STD_LOGIC;
aluop: out STD_LOGIC_VECTOR(1 downto 0));
assign {regwrite, regdst, alusrc, branch, memwrite, end;
memtoreg, jump, aluop} = controls;
architecture behave of maindec is
signal controls: STD_LOGIC_VECTOR(8 downto 0);
always_comb
begin
case(op) process(all) begin
6'b000000: controls <= 9'b110000010; // RTYPE case op is
6'b100011: controls <= 9'b101001000; // LW when "000000" => controls <= "110000010"; RTYPE
6'b101011: controls <= 9'b001010000; // SW when "100011" => controls <= "101001000"; LW
6'b000100: controls <= 9'b000100001; // BEQ when "101011" => controls <= "001010000"; SW
6'b001000: controls <= 9'b101000000; // ADDI when "000100" => controls <= "000100001"; BEQ
6'b000010: controls <= 9'b000000100; // J when "001000" => controls <= "101000000"; ADDI
default: controls <= 9'bxxxxxxxxx; // illegal op when "000010" => controls <= "000000100"; J
endcase when others => controls <= ""; illegal op
endmodule end case;
end process;
(regwrite, regdst, alusrc, branch, memwrite,

memtoreg, jump, aluop(1 downto 0)) <= controls;
end;
608
Exemplo HDL 7.4 DECODIFICADOR D A ALU
SystemVerilog VHDL
module aludec(input logic [5:0] funct,
input logic [1:0] aluop, entity aludec is ALU control decoder
output logic [2:0] alucontrol); port(funct: in STD_LOGIC_VECTOR(5 downto 0);
always_comb aluop: in STD_LOGIC_VECTOR(1 downto 0);
case(aluop) alucontrol: out STD_LOGIC_VECTOR(2 downto 0));
2'b00: alucontrol <= 3'b010; // add (for lw/sw/addi) end;
2'b01: alucontrol <= 3'b110; // sub (for beq)
default: case(funct) // R-type instructions architecture behave of aludec is
6'b100000: alucontrol <= 3'b010; // add begin
6'b100010: alucontrol <= 3'b110; // sub process(all) begin
6'b100100: alucontrol <= 3'b000; // and case aluop is
6'b100101: alucontrol <= 3'b001; // or when "00" => alucontrol <= "010"; add (for 1w/sw/addi)
6'b101010: alucontrol <= 3'b111; // slt when "01" => alucontrol <= "110"; sub (for beq)
default: alucontrol <= 3'bxxx; // ??? when others => case funct is R-type instructions
endcase when "100000" => alucontrol <= "010"; add
endcase when "100010" => alucontrol <= "110"; sub
endmodule when "100100" => alucontrol <= "000"; and
when "100101" => alucontrol <= "001"; or
when "101010" => alucontrol <= "111"; slt
when others => alucontrol <= ""; ???
end case;
end case;
end process;
end;
609
Exemplo HDL 7.5 CAMINHO DE DADOS
SystemVerilog VHDL
module datapath(input logic clk, reset, use IEEE.STD_LOGIC_ARITH.all;
input logic memtoreg, pcsrc,
input logic alusrc, regdst, entity datapath is MIPS datapath
input logic regwrite, jump, port(clk, reset: in STD_LOGIC;
input logic [2:0] alucontrol, memtoreg, pcsrc: in STD_LOGIC;
output logic zero, alusrc, regdst: in STD_LOGIC;
output logic [31:0] pc, regwrite, jump: in STD_LOGIC;
input logic [31:0] instr, alucontrol: in STD_LOGIC_VECTOR(2 downto 0);
output logic [31:0] aluout, writedata, zero: out STD_LOGIC;
input logic [31:0] readdata); pc: buffer STD_LOGIC_VECTOR(31 downto 0);
logic [4:0] writereg; instr: in STD_LOGIC_VECTOR(31 downto 0);
logic [31:0] pcnext, pcnextbr, pcplus4, pcbranch; aluout, writedata: buffer STD_LOGIC_VECTOR(31 downto 0);
logic [31:0] signimm, signimmsh; readdata: in STD_LOGIC_VECTOR(31 downto 0));
logic [31:0] srca, srcb; end;
logic [31:0] result;
architecture struct of datapath is
// next PC logic component alu
flopr #(32) pcreg(clk, reset, pcnext, pc); port(a, b: in STD_LOGIC_VECTOR(31 downto 0);
adder pcadd1(pc, 32'b100, pcplus4); alucontrol: in STD_LOGIC_VECTOR(2 downto 0);
sl2 immsh(signimm, signimmsh); result: buffer STD_LOGIC_VECTOR(31 downto 0);
adder pcadd2(pcplus4, signimmsh, pcbranch); zero: out STD_LOGIC);
mux2 #(32) pcbrmux(pcplus4, pcbranch, pcsrc, pcnextbr); end component;
mux2 #(32) pcmux(pcnextbr, {pcplus4[31:28], component regfile
instr[25:0], 2'b00}, jump, pcnext); port(clk: in STD_LOGIC;
we3: in STD_LOGIC;
// register file logic ra1, ra2, wa3: in STD_LOGIC_VECTOR(4 downto 0);
regfile rf(clk, regwrite, instr[25:21], instr[20:16], wd3: in STD_LOGIC_VECTOR(31 downto 0);
writereg, result, srca, writedata); rd1, rd2: out STD_LOGIC_VECTOR(31 downto 0));
mux2 #(5) wrmux(instr[20:16], instr[15:11], end component;
regdst, writereg); component adder
mux2 #(32) resmux(aluout, readdata, memtoreg, result); port(a, b: in STD_LOGIC_VECTOR(31 downto 0);
signext se(instr[15:0], signimm); y: out STD_LOGIC_VECTOR(31 downto 0));
end component;
// ALU logic component sl2
mux2 #(32) srcbmux(writedata, signimm, alusrc, srcb); port(a: in STD_LOGIC_VECTOR(31 downto 0);
alu alu(srca, srcb, alucontrol, aluout, zero); y: out STD_LOGIC_VECTOR(31 downto 0));
endmodule end component;
component signext
end component;
component flopr generic(width: integer);
610
d: in STD_LOGIC_VECTOR(width-1 downto 0);

q: out STD_LOGIC_VECTOR(width-1 downto 0));
end component;
component mux2 generic(width: integer);
port(d0, d1: in STD_LOGIC_VECTOR(width-1 downto 0);
s: in STD_LOGIC;
y: out STD_LOGIC_VECTOR(width-1 downto 0));
end component;
signal writereg: STD_LOGIC_VECTOR(4 downto 0);
signal pcjump, pcnext,
pcnextbr, pcplus4,
pcbranch: STD_LOGIC_VECTOR(31 downto 0);
signal signimm, signimmsh: STD_LOGIC_VECTOR(31 downto 0);
signal srca, srcb, result: STD_LOGIC_VECTOR(31 downto 0);
begin
next PC logic
pcjump <= pcplus4(31 downto 28) & instr(25 downto 0) & "00";
pcreg: flopr generic map(32) port map(clk, reset, pcnext, pc);
pcadd1: adder port map(pc, X"00000004", pcplus4);
immsh: sl2 port map(signimm, signimmsh);
pcadd2: adder port map(pcplus4, signimmsh, pcbranch);
pcbrmux: mux2 generic map(32) port map(pcplus4, pcbranch,
pcsrc, pcnextbr);
pcmux: mux2 generic map(32) port map(pcnextbr, pcjump, jump,
pcnext);
register file logic
rf: regfile port map(clk, regwrite, instr(25 downto 21),
instr(20 downto 16), writereg, result, srca,
writedata);
wrmux: mux2 generic map(5) port map(instr(20 downto 16),
instr(15 downto 11),
regdst, writereg);
resmux: mux2 generic map(32) port map(aluout, readdata,
memtoreg, result);
se: signext port map(instr(15 downto 0), signimm);
ALU logic
srcbmux: mux2 generic map(32) port map(writedata, signimm,
alusrc, srcb);
mainalu: alu port map(srca, srcb, alucontrol, aluout, zero);
end;
611
7.6.2. Blocos de Construo Genricos

Esta seo contm blocos genricos de construo que podem ser teis em qualquer
microarquitetura MIPS, incluindo um banco de registros, somador, unidade de deslocamento para a
esquerda, unidade de extenso de sinal, flip-flop resettable, e multiplexador. O HDL para a ALU
deixado para o Exerccio 5.9.
Exemplo HDL 7.6 BANCO DE REGISTROS
SystemVerilog VHDL
module regfile(input logic clk, use IEEE.NUMERIC_STD_UNSIGNED.all;
input logic we3,
input logic [4:0] ra1, ra2, wa3, entity regfile is three-port register file
input logic [31:0] wd3, port(clk: in STD_LOGIC;
output logic [31:0] rd1, rd2); we3: in STD_LOGIC;
logic [31:0] rf[31:0]; ra1, ra2, wa3: in STD_LOGIC_VECTOR(4 downto 0);
wd3: in STD_LOGIC_VECTOR(31 downto 0);
// three ported register file rd1, rd2: out STD_LOGIC_VECTOR(31 downto 0));
// read two ports combinationally end;
// write third port on rising edge of clk
// register 0 hardwired to 0 architecture behave of regfile is
// note: for pipelined processor, write third port type ramtype is array (31 downto 0) of STD_LOGIC_VECTOR(31
// on falling edge of clk downto 0);
signal mem: ramtype;
if (we3) rf[wa3] <= wd3; three-ported register file
assign rd1 = (ra1 ! = 0) ? rf[ra1] : 0; read two ports combinationally
assign rd2 = (ra2 ! = 0) ? rf[ra2] : 0; write third port on rising edge of clk
endmodule register 0 hardwired to 0
note: for pipelined processor, write third port
on falling edge of clk
process(clk) begin
if we3 = '1' then mem(to_integer(wa3)) <= wd3;
end if;
end if;
end process;
process(all) begin
if (to_integer(ra1) = 0) then rd1 <= X"00000000";
register 0 holds 0
else rd1 <= mem(to_integer(ra1));
end if;
if (to_integer(ra2) = 0) then rd2 <= X"00000000";
else rd2 <= mem(to_integer(ra2));
end if;
end process;
end;
612
Exemplo HDL 7.7 SOMADOR
SystemVerilog VHDL
module adder(input logic [31:0] a, b, library IEEE; use IEEE.STD_LOGIC_1164.all;

output logic [31:0] y); use IEEE.NUMERIC_STD_UNSIGNED.all;
entity adder is adder
assign y = a + b; port(a, b: in STD_LOGIC_VECTOR(31 downto 0);
end;
architecture behave of adder is

begin
y <= a+b;
end;
Exemplo HDL 7.8 DESLOCAMENTO PARA A ESQUERDA (MULTIPLICA POR 4)
SystemVerilog VHDL
module sl2(input logic [31:0] a, library IEEE; use IEEE.STD_LOGIC_1164.all;
// shift left by 2 entity sl2 is shift left by 2
assign y = {a[29:0], 2'b00}; port(a: in STD_LOGIC_VECTOR(31 downto 0);
end;
architecture behave of sl2 is

begin
y <= a(29 downto 0) & "00";
end;
613
Exemplo HDL 7.9 EXTENSO DE SINAL
SystemVerilog VHDL
module signext(input logic [15:0] a,
output logic [31:0] y); entity signext is sign extender
assign y = {{16{a[15]}}, a}; y: out STD_LOGIC_VECTOR(31 downto 0));
endmodule end;
architecture behave of signext is

begin
y <= X"ffff" & a when a(15) else X"0000" & a;
end;
Exemplo HDL 7.10 FLIP-FLOP RESETTABLE
SystemVerilog VHDL
module flopr #(parameter WIDTH = 8) use IEEE.STD_LOGIC_ARITH.all;
(input logic clk, reset,
input logic [WIDTH-1:0] d, entity flopr is flip-flop with synchronous reset
output logic [WIDTH-1:0] q); generic (width: integer);
always_ff @(posedge clk, posedge reset) port(clk, reset: in STD_LOGIC;
if (reset) q <= 0; d: in STD_LOGIC_VECTOR(width-1 downto 0);
else q <= d; q: out STD_LOGIC_VECTOR(width-1 downto 0));
endmodule end;
architecture asynchronous of flopr is

begin
if reset then q <= (others => '0');
q <= d;
end if;
end process;
end;
614
Exemplo HDL 7.11 MULTIPLEXADOR
SystemVerilog VHDL
module mux2 #(parameter WIDTH = 8) library IEEE; use IEEE.STD_LOGIC_1164.all;

(input logic [WIDTH-1:0] d0, d1,
input logic s, entity mux2 is two-input multiplexer
output logic [WIDTH-1:0] y); generic(width: integer := 8);
assign y = s ? d1 : d0; port(d0, d1: in STD_LOGIC_VECTOR(width-1 downto 0);
endmodule s: in STD_LOGIC;
y: out STD_LOGIC_VECTOR(width-1 downto 0));
end;
architecture behave of mux2 is

begin
y <= d1 when s else d0;
end;
7.6.3. Testbench
O testbench MIPS carrega um programa nas memrias. O programa na Figura 7.60 exercita todas
as instrues atravs da realizao de um clculo que deve produzir a resposta correta somente se
todas as instrues esto funcionando corretamente. Especificamente, o programa ir escrever o
valor 7 para o endereo 84 se ele executado corretamente, e improvvel que o faa se o hardware
tiver algum problema. Este um exemplo de teste ad hoc.
O cdigo de mquina armazenado num ficheiro chamado memfile.dat hexadecimal (ver Figura
7.61), que carregado pelo testbench durante a simulao. O arquivo consiste no cdigo de mquina
para as instrues, uma instruo por linha.
O cdigo VHDL do testbench, do mdulo de alto nvel MIPS, e da memria externa so dados nos
seguintes exemplos. As memrias neste exemplo armazenam 64 palavras cada.
615
20020005 # mipstest.asm
2003000c # David_Harris@hmc.edu, Sarah_Harris@hmc.edu 31 March 2012
2067fff7 #
00e22025 # Test the MIPS processor.
00642824 # add, sub, and, or, slt, addi, lw, sw, beq, j
00a42820 # If successful, it should write the value 7 to address 84
10a7000a # Assembly Description Address Machine
0064202a main: addi $2, $0, 5 # initialize $2 = 5 0 20020005
10800001 addi $3, $0, 12 # initialize $3 = 12 4 2003000c
20050000 addi $7, $3, 9 # initialize $7 = 3 8 2067fff7
00e2202a or $4, $7, $2 # $4 = (3 OR 5) = 7 c 00e22025
00853820 and $5, $3, $4 # $5 = (12 AND 7) = 4 10 00642824
00e23822 add $5, $5, $4 # $5 = 4 + 7 = 11 14 00a42820
ac670044 beq $5, $7, end # shouldn't be taken 18 10a7000a
8c020050 slt $4, $3, $4 # $4 = 12 < 7 = 0 1c 0064202a
08000011 beq $4, $0, around # should be taken 20 10800001
20020001 addi $5, $0, 0 # shouldnt happen 24 20050000
ac020054 around: slt $4, $7, $2 # $4 = 3 < 5 = 1 28 00e2202a
Figura 7.61 Contedo do add $7, $4, $5 # $7 = 1 + 11 = 12 2c 00853820
memfie.dat sub $7, $7, $2 # $7 = 12 5 = 7 30 00e23822
sw $7, 68($3) # [80] = 7 34 ac670044
lw $2, 80($0) # $2 = [80] = 7 38 8c020050
j end # should be taken 3c 08000011
addi $2, $0, 1 # shouldn't happen 40 20020001
end: sw $2, 84($0) # write mem[84] = 7 44 ac020054
Figura 7.60 Assembly e cdigo mquina para o programa de teste MIPS
616
Exemplo HDL 7.12 TESTBENCH MIPS
SystemVerilog VHDL
module testbench(); library IEEE;

logic clk; use IEEE.STD_LOGIC_1164.all; use IEEE.NUMERIC_STD_UNSIGNED.all;
logic reset;
entity testbench is
logic [31:0] writedata, dataadr; end;
logic memwrite; architecture test of testbench is
component top
// instantiate device to be tested port(clk, reset: in STD_LOGIC;
top dut (clk, reset, writedata, dataadr, memwrite); writedata, dataadr: out STD_LOGIC_VECTOR(31 downto 0);
memwrite: out STD_LOGIC);
// initialize test end component;
initial signal writedata, dataadr: STD_LOGIC_VECTOR(31 downto 0);
begin signal clk, reset, memwrite: STD_LOGIC;
reset <= 1; # 22; reset <= 0; begin
end
instantiate device to be tested
// generate clock to sequence tests dut: top port map(clk, reset, writedata, dataadr, memwrite);
always
begin Generate clock with 10 ns period
clk <= 1; # 5; clk <= 0; # 5; process begin
end clk <= '1';
wait for 5 ns;
// check results clk <= '0';
always @(negedge clk) wait for 5 ns;
begin end process;
if (memwrite) begin Generate reset for first two clock cycles
if (dataadr===84 & writedata===7) begin process begin
$display("Simulation succeeded"); reset <= '1';
$stop; wait for 22 ns;
end else if (dataadr !==80) begin reset <= '0';
$display("Simulation failed"); wait;
$stop; end process;
end check that 7 gets written to address 84 at end of program
end process(clk) begin
end if (clk'event and clk = '0' and memwrite = '1') then
endmodule if (to_integer(dataadr) = 84 and to_integer
(writedata) = 7) then
report "NO ERRORS: Simulation succeeded" severity failure;
elsif (dataadr /= 80) then
report "Simulation failed" severity failure;
end if;
end if;
end process;
end;
617
Exemplo HDL 7.13 MODELO DE ALTO NVEL MIPS
SystemVerilog VHDL
module top(input logic clk, reset, library IEEE;

output logic [31:0] writedata, dataadr, use IEEE.STD_LOGIC_1164.all; use IEEE.NUMERIC_STD_UNSIGNED.all;
output logic memwrite);
entity top is top-level design for testing
logic [31:0] pc, instr, readdata; port(clk, reset: in STD_LOGIC;
writedata, dataadr: buffer STD_LOGIC_VECTOR(31 downto 0);
// instantiate processor and memories memwrite: buffer STD_LOGIC);
mips mips(clk, reset, pc, instr, memwrite, dataadr, end;
writedata, readdata);
imem imem(pc[7:2], instr); architecture test of top is
dmem dmem(clk, memwrite, dataadr, writedata, readdata); component mips
endmodule port(clk, reset: in STD_LOGIC;
pc: out STD_LOGIC_VECTOR(31 downto 0);
instr: in STD_LOGIC_VECTOR(31 downto 0);
memwrite: out STD_LOGIC;
aluout, writedata: out STD_LOGIC_VECTOR(31 downto 0);
readdata: in STD_LOGIC_VECTOR(31 downto 0));
end component;
component imem
rd: out STD_LOGIC_VECTOR(31 downto 0));
end component;
component dmem
port(clk, we: in STD_LOGIC;
a, wd: in STD_LOGIC_VECTOR(31 downto 0);
rd: out STD_LOGIC_VECTOR(31 downto 0));
end component;
signal pc, instr,
readdata: STD_LOGIC_VECTOR(31 downto 0);
begin
instantiate processor and memories
mips1: mips port map(clk, reset, pc, instr, memwrite,
dataadr, writedata, readdata);
imem1: imem port map(pc(7 downto 2), instr);
dmem1: dmem port map(clk, memwrite, dataadr, writedata, readdata);
end;
618
Exemplo HDL 7.14 MEMRIA DE DADOS MIPS
SystemVerilog VHDL
module dmem(input logic clk, we, library IEEE;

input logic [31:0] a, wd, use IEEE.STD_LOGIC_1164.all; use STD.TEXTIO.all;
output logic [31:0] rd); use IEEE.NUMERIC_STD_UNSIGNED.all;
logic [31:0] RAM[63:0];
entity dmem is data memory
assign rd = RAM[a[31:2]]; // word aligned port(clk, we: in STD_LOGIC;
a, wd: in STD_LOGIC_VECTOR (31 downto 0);
always_ff @(posedge clk) rd: out STD_LOGIC_VECTOR (31 downto 0));
if (we) RAM[a[31:2]] <= wd; end;
endmodule architecture behave of dmem is
begin
process is
type ramtype is array (63 downto 0) of
STD_LOGIC_VECTOR(31 downto 0);
variable mem: ramtype;
begin
read or write memory
loop
if (we='1') then mem (to_integer(a(7 downto 2))):= wd;
end if;
end if;
rd <= mem (to_integer(a (7 downto 2)));
wait on clk, a;
end loop;
end process;
end;
619
Exemplo HDL 7.15 MEMRIA DE INSTRUES MIPS
SystemVerilog VHDL
module imem(input logic [5:0] a, library IEEE;

output logic [31:0] rd); use IEEE.STD_LOGIC_1164.all; use STD.TEXTIO.all;
logic [31:0] RAM[63:0];
entity imem is instruction memory
initial port(a: in STD_LOGIC_VECTOR(5 downto 0);
$readmemh("memfile.dat", RAM); rd: out STD_LOGIC_VECTOR(31 downto 0));
end;
assign rd = RAM[a]; // word aligned
endmodule architecture behave of imem is
begin
process is
file mem_file: TEXT;
variable L: line;
variable ch: character;
variable i, index, result: integer;
type ramtype is array (63 downto 0) of
STD_LOGIC_VECTOR(31 downto 0);
variable mem: ramtype;
begin
initialize memory from file
for i in 0 to 63 loop set all contents low
mem(i) := (others => '0');
end loop;
index := 0;
FILE_OPEN (mem_file, "C:/docs/DDCA2e/hdl/memfile.dat",
READ_MODE);
while not endfile(mem_file) loop
readline(mem_file, L);
result := 0;
for i in 1 to 8 loop
read (L, ch);
if '0' <= ch and ch <= '9' then
result := character'pos(ch) - character'pos('0');
elsif 'a' <= ch and ch <= 'f' then
result := character'pos(ch) - character'pos('a')+10;
else report "Format error on line" & integer'
image(index) severity error;
end if;
mem(index)(35-i*4 downto 32-i*4) :=
to_std_logic_vector(result,4);
end loop;
index := index + 1;
end loop;
620
read memory
loop
rd <= mem(to_integer(a));
wait on a;
end loop;
end process;
end;
7.7. EXCEES*
A seo 6.7.2 introduziu as excees, que causam alteraes no programadas no fluxo de um
programa. Nesta seo, queremos melhorar o processador multi-ciclo para suportar dois tipos de
excees: instrues indefinidas e overflows aritmticos. O suporte de excees noutras
microarquiteturas segue princpios semelhantes.
Conforme descrito na Seo 6.7.2, quando uma exceo ocorre, o processador copia o PC para o
registro EPC e escreve um cdigo no registro Cause indicando a origem da exceo. As causas de
exceo incluem 0x28 para obter instrues indefinidos e 0x30 para overflow (ver Tabela 6.7). O
processador em seguida, salta para o manipulador de exceo no endereo de memria 0x80000180.
O manipulador de exceo o cdigo que responde a exceo. Faz parte do sistema operacional.
Tambm tal como discutido na Seo 6.7.2, os registros de exceo so parte do co-processador
0, uma parte do processador de MIPS que utilizado para as funes do sistema. O co-processador
0 define at 32 registradores de uso especial, incluindo o Cause e o EPC. O manipulador de exceo
pode usar a instruo mfc0 (move from co-processador 0) para copiar estes registros de propsitos
especiais para os registros de propsito gerais no banco de registros; o registro Cause no co-
processador 0 o registro 13 e EPC o registro 14.
Para lidar com as excees, preciso acrescentar os registros EPC e Cause ao caminho de dados e
ampliar o multiplexador PCSrc para aceitar o endereo do manipulador de exceo, como mostrado
na Figura 7.62. Os dois novos registros tm como enable de escrita, EPCWrite e CauseWrite, para
armazenar o PC e a causa da exceo quando uma exceo ocorre. A causa gerada por um
621
multiplexador que seleciona o cdigo apropriado para a exceo. A ALU tambm deve gerar um sinal
de excesso, como foi discutido na Seo 5.2.4
Figura 7.62 Caminho de dados suportando overflow e excees indefinidas de instrues
Para apoiar a instruo mfc0, tambm adicionamos uma forma de selecionar os registros do co-
processador 0 e escreve-los no banco de registro, como mostrado na Figura 7.63. A instruo mfc0
especifica o registro do co-processador 0 por Instr15:11; neste diagrama, apenas os registros Cause e
EPC so suportados. Adicionamos outra entrada ao multiplexador MemtoReg para selecionar o valor
do co-processador 0.
O controlador modificado mostrado na Figura 7.64. O controlador recebe a flag de overflow da
ALU. Gera trs novos sinais de controle: uma para escrever no EPC, um segundo para escrever no
registro Cause, e um terceiro para selecionar a causa. Ele tambm inclui dois novos estados para
apoiar as duas excees e outro estado para lidar com mfc0.
Se o controlador recebe uma instruo indefinido (uma que no saiba como lidar), ele passa para
S12, guarda o PC no EPC, escreve 0x28 ao registro Cause, e salta para o manipulador de exceo. Da
622
mesma forma, se o controlador detecta o overflow aritmtico numa instruo add ou sub, ele passa a
S13, salva o PC no EPC, escreve 0x30 no registro Cause, e salta para o manipulador de exceo. Note-se
que, quando ocorre uma exceo, a instruo descartada e o banco de registros no escrito. Quando
uma instruo mfc0 decodificada, o processador vai para S14 e escreve o registro adequado do co-
processador 0 no banco de registros principal.
Figura 7.63 Caminho de dados suportando mfc0
623
Figura 7.64 Controlador com suporte de excees e de mfc0
624
7.8. MICROARQUITETURA AVANADA*

Os microprocessadores de alto desempenho utilizam uma grande variedade de tcnicas para
executar mais rapidamente os programas. Recorde-se que o tempo requerido para executar um
programa proporcional ao perodo do relgio e ao nmero de ciclos de relgio por instruo (CPI).
Assim, para aumentar o desempenho gostaramos de acelerar o relgio e/ou reduzir o CPI. Esta seo
examina algumas tcnicas de acelerao existentes. Os detalhes da implementao tornaram-se
bastante complexos, por isso vamos concentrar-nos sobre os conceitos. O livro de texto de Hennessy
& Pattersons Computer Architecture uma referncia definitiva se o leitor quiser compreender
totalmente os detalhes.
A cada 2 a 3 anos, os avanos na fabricao CMOS reduzem as dimenses do transstor em 30%,
dobrando o nmero de transstores que podem caber num chip. Um processo de fabrico
caracterizado pela sua dimenso de trao, que indica o menor transstor que pode ser construdo de
forma fivel. Os transstores menores so mais rpidos e geralmente consomem menos energia. Assim,
mesmo se a microarquitetura no muda, a frequncia do relgio pode aumentar porque todas as
portas so mais rpidas. Para alm disso, transstores menores permitem colocar mais transstores
num chip. As microarquiteturas usam os transstores adicionais para construir processadores mais
complexos ou colocar mais processadores num chip. Infelizmente, o consumo de energia aumenta com
o nmero de transstores e a velocidade a que operam (ver Seo 1.8). O consumo de energia agora
uma preocupao essencial. Os projetistas de microprocessadores tm a difcil tarefa de fazer
malabarismos com os compromissos entre a velocidade, a potncia e o custo para chips com bilhes
de transstores em alguns dos sistemas mais complexos que os seres humanos j construiram.
7.8.1. Profundidade do Pipeline
Alm dos avanos na fabricao, a maneira mais fcil para acelerar o relgio partir o pipeline em
vrios estgios. Cada estgio contm menos lgica, para que ele possa executar mais rpido. Este
Captulo considerou um pipeline de cinco estgios clssico, mas atualmente comum usar 10 a 20
estgios.
625
O nmero mximo de estgios do pipeline limitado pelos hazards de pipeline, a sobrecarga de

sequenciamento, e o custo. Os pipelines mais longos introduzem mais dependncias. Algumas das
dependncias podem ser resolvidas por encaminhamento, mas outras requerem stalls, que
aumentam o CPI. Os registros de pipeline entre cada estgio tm sobrecarga de sequenciamento de
seu tempo de setup e atraso clk-to-Q (bem como do skew do relgio). Esta sobrecarga de
sequenciamento faz com que a adio de mais estgios de pipeline proporcione retornos
decrescentes. Finalmente, a adio de mais estgios aumenta o custo por causa dos registros de
pipeline extras e do hardware necessrios para lidar com os harzards.
Exemplo 7.11 PROFUNDIDADE DO PIPELINE

Considere a construo de um processador com pipeline por quebra do processador de ciclo-nico
em N estgios (N 5). O processador de ciclo-nico tem um atraso de propagao de 875 ps atravs
da lgica combinacional. A sobrecarga de sequenciamento de um registro de 50 ps. Assume-se que
o atraso combinacional pode ser arbitrariamente dividido num qualquer nmero de estgios e que a
lgica de harzard do pipeline no aumenta o atraso. O pipeline de cinco estgios no Exemplo 7.9 tem
um CPI de 1,15. Suponha que cada estgio adicional aumenta o CPI de 0,1 por causa dos erros de
previso dos branchs e outros hazards dos pipelines. Quantos estgios de pipeline devem ser usados
para conseguir que o processador execute programas o mais rapidamente possvel?
Soluo: Se o atraso de 875 ps da lgica combinacional dividido em N estgios e cada estgio
tambm tem um custo de 50 ps de sobrecarga de sequenciamento para o seu registro de pipeline, o
tempo de ciclo Tc = (875 / N + 50) ps. O CPI de 1,15 + 0,1 (N - 5). O tempo por instruo, ou o tempo
de instruo, o produto do tempo de ciclo pelo o CPI. A Figura 7.65 representa o tempo de ciclo e o
tempo de instruo versus o nmero de estgios. O tempo de instruo tem um mnimo de 227 ps
para N = 11 estgios. Esse mnimo apenas ligeiramente melhor do que os 245 ps por instruo
alcanado com um pipeline de seis estgios.
No final de 1990 e incio de 2000, os microprocessadores foram comercializados em grande parte
com base na frequncia de relgio (1/Tc). Isto levou a os microprocessadores a usarem pipelines muito
profundos (20 a 31 estgios no Pentium 4) para maximizar a frequncia do relgio, mesmo que os
benefcios para o desempenho global fossem questionveis. A capacidade proporcional frequncia
626
do relgio e tambm aumenta com o nmero de registros do pipeline, ento agora que o consumo
de energia to importante, a profundidade do pipeline est a diminuir.
Figura 7.65 Tempo de ciclo e tempo de instruo versus o nmero de estgios do pipeline
7.8.2. Previso de Branch

Um processador com pipeline ideal teria um CPI de 1. A branch misprediction penalty uma das
principais razes para o aumento do CPI. Com os pipelines a usar profundidades maiores, os branchs
so resolvidos mais tarde no pipeline. Assim, a branch misprediction penalty torna-se maior, porque
627
todas as instrues obtidas aps o erro de previso de branch devem ser descartadas. Para resolver
este problema, os processadores com pipeline usam um preditor de branch para adivinhar se o branch
deve ser realizado. Lembre-se que o nosso pipeline da Seo 7.5.3 simplesmente previa que os
branchs nunca so realizados.
Alguns branchs ocorrem quando um programa chega ao fim de um ciclo (por exemplo, uma
estrutura while ou for) e retorna ao incio para repetir o ciclo. Os ciclos tendem a ser executados
muitas vezes, por isso, estes branchs de retorno so normalmente realizados. A forma mais simples
de previso de desvios verifica a direo dos branchs de retorno e prev que branchs de retorno
devem ser realizados. Isto chamado de previso de desvio esttico, uma vez que no dependem da
histria do programa.
Os branchs para a frente so difceis de prever, sem saber mais sobre o programa especfico.
Portanto, a maioria dos processadores usa a previso de desvio dinmico, que usam a histria da
execuo do programa para adivinhar se um branch deve ser realizado. Os preditores de desvio
dinmicos mantm uma tabela das ltimas centenas (ou milhares) instrues de branch que o
processador executou. A tabela, s vezes chamada de buffer de destino de desvio, inclui o destino do
branch e um historial de se foi realizado.
Para ver a operao de preditores de desvio dinmicos, considere o seguinte cdigo de ciclo do
Exemplo de Cdigo 6.20. O ciclo repete 10 vezes, e o beq fora do ciclo tomado apenas no ltimo
momento.
add $s1, $0, $0 # sum = 0
addi $s0, $0, 0 # i = 0
addi $t0, $0, 10 # $t0 = 10
for:
beq $s0, $t0, done # if i== 10, branch to done
add $s1, $s1, $s0 # sum = sum + i
addi $s0, $s0, 1 # increment i
j for
done:
628
O preditor dinmico de desvio de 1-bit lembra-se se o branch foi feita pela ltima vez e prev que
ele vai fazer a mesma coisa na prxima vez. Enquanto o ciclo se estiver a repetir, ele lembra que o
beq no foi realizado pela ltima vez e prev que no deve ser realizado na prxima vez. Esta uma
previso correta, at o ltimo branch do ciclo, quando o branch realizado. Infelizmente, se o ciclo
executado novamente, o preditor de desvio lembra que o ltimo branch foi realizado. Portanto,
incorretamente prev que o branch deve ser tomado quando o ciclo executado pela primeira vez
novamente. Em resumo, um preditor de desvio de 1-bit erra na previso dos primeiros e ltimos
branchs de um ciclo.
Figura 7.66 Diagrama de transio de estado do preditor de branch de 2-bits
Um preditor dinmico de desvio de 2-bits resolve este problema fazendo uso de quatro estados:
fortemente realizado, fracamente realizado, fracamente no realizado, e fortemente no realizado,
como mostrado na Figura 7.66. Quando o ciclo est repetindo, ele entra no estado "fortemente no
realizado" e prev que o branch no deve ser realizado na prxima vez. Isto correto, at ao ltimo
branch do ciclo, que realizado e move o preditor para o estado "fracamente no realizado". Quando
o ciclo executado pela primeira vez novamente, o previsor de ramos prev corretamente que o
ramo no deve ser realizado e reentra no estado "fortemente no realizado". Em resumo, um
preditor de desvio de 2 bits erra na previso apenas no ltimo branch de um ciclo.
Como se pode imaginar, os preditores de desvio podem ser usados para rastrear ainda mais o
historial do programa para aumentar a preciso das previses. Bons preditores de desvio conseguem
alcanar 90% de preciso em programas tpicos.
O preditor de desvio opera no estgio de fetch do pipeline de modo que ele pode determinar qual
a instruo a executar o prximo ciclo. Quando se prev que o branch deve ser realizado, o
629
processador busca a instruo do branch de destino armazenado no buffer de destino de branch. Ao

manter o controle dos destinos de ambos os branchs e jumps no buffer de destino de branch, o
Um processador escalar trabalha sobre
processador tambm pode evitar o flush do pipeline durante instrues de jump.
um pedao de dados de cada vez. Um
7.8.3. Processador Superescalar processador vectorial trabalha em vrias
Um processador superescalar contm vrias cpias do hardware do caminho de dados para partes dos dados com uma nica
executar mltiplas instrues simultaneamente. A Figura 7.67 apresenta um diagrama de blocos de instruo. Um processador superescalar
um processador superescalar bidireccional que obtm e executa duas instrues por ciclo. O caminho trabalha vrias instrues de cada vez,
cada uma das quais opera sobre uma
de dados obtm duas instrues num dado momento a partir da memria de instrues. Tem um
parte de dados. O nosso processador com
banco de registros de seis elementos para ler quatro operandos de origem e escrever dois resultados
pipeline MIPS um processador escalar.
de volta em cada ciclo. Ele tambm contm duas ALU e uma memria de dados de dois elementos Os processadores vetoriais eram
para executar as duas instrues ao mesmo tempo. populares nos supercomputadores em
1980 e 1990, porque tratavam
eficientemente os longos vectores de
dados comuns em clculos cientficos. Os
microprocessadores modernos de
elevado desempenho so superescalar,
porque a tratamento de vrias instrues
independentes mais flexvel do que
processamento vectorial. No entanto, os
processadores modernos tambm
incluem hardware para lidar com vectores
dados curtos sendo comuns em
Figura 7.67 Caminho de dados superescalar aplicaes multimdia e grficas. Estas so
chamadas de unidades de instruo nica
A Figura 7.68 mostra um diagrama de pipeline ilustrando o processador superescalar de duas vias
dados mltiplos (SIMD).
a executar duas instrues em cada ciclo. Para este programa, o processador tem um CPI de 0,5. Os
projetistas referem-se comumente ao recproco do CPI como instrues por ciclo, ou IPC. Este
processador tem um IPC de 2 neste programa.
630
Figura 7.68 Vista abstrata de um pipeline superescalar em funcionamento
Executar muitas instrues ao mesmo tempo difcil devido s dependncias. Por exemplo, a
Figura 7.69 apresenta um diagrama de pipeline a executar um programa com dependncias de
dados. As dependncias no cdigo so mostradas a azul. A instruo add dependente de $t0, que
produzido pela instruo lw, por isso no pode ser tratada ao mesmo tempo como lw. Na verdade,
a instruo add provoca um stalls durante mais um ciclo para que lw possa encaminhar $t0 para
add no ciclo 5. As outras dependncias (entre sub e and baseadas em $t0, e entre or e sw
baseadas em $t3) so tratadas por meio do envio dos resultados produzidos num ciclo para ser
consumidos no prximo. Este programa, tambm apresentado a seguir, requer cinco ciclos para seis
instrues, para um IPC de 1,17.
Lw $t0, 40($s0)
add $t1, $t0, $s1
sub $t0, $s2, $s3
and $t2, $s4, $t0
or $t3, $s5, $s6
sw $s7, 80($t3)
631
Figura 7.69 Programa com dependncias de dados
632
Lembre-se que o paralelismo ocorre nas formas temporais e espaciais. O pipelining e um caso de
paralelismo temporal. Vrias unidades de execuo um caso de paralelismo espacial. Os
processadores superescalares exploraram ambas as formas de paralelismo para espremer um
desempenho superior, longe dos nossos processadores de ciclo-nico e multi-ciclo.
Os processadores comerciais podem ter trs, quatro ou at seis vias superescalares. Eles devem
lidar com hazards de controle, tais como branchs, bem como os hazards de dados. Infelizmente, os
programas reais tm muitas dependncias, os processadores superescalares raramente utilizam
plenamente todas as unidades de execuo. Alm disso, o grande nmero de unidades de execuo
e redes de encaminhamento complexos consomem grandes quantidades de circuitos e energia.
7.8.4. Processador Out-of-Order
Para lidar com o problema das dependncias, um processador out-of-order inspeciona frente
atravs de muitas instrues para obter, ou iniciar a execuo, de instrues independentes o mais
rapidamente possvel. As instrues podem ser obtidas numa ordem diferente do que foi escrito pelo
programador, enquanto as dependncias so observadas para que o programa produza o resultado
pretendido.
Considere a execuo do mesmo programa da Figura 7.69 num processador superescalar out-of-
order de duas vias. O processador pode obter at duas instrues por ciclo de qualquer parte do
programa, desde que as dependncias sejam observadas. A Figura 7.70 mostra as dependncias de
dados e a operao do processador. As classificaes de dependncias como RAW e WAR sero
discutidas brevemente. As restries na obteno de instrues so descritas abaixo.
Ciclo 1
- A instruo lw obtida.
- As instrues add, sub, e and so dependentes de lw por meio de $t0, ento elas
no podem ser obtidas ainda. No entanto, a instruo or independente, de modo que
tambm obtida.
633
Figura 7.70 Execuo de um programa out-of-order com dependncia
Ciclo 2
- Lembre-se que h uma latncia de dois ciclos entre quando a instruo lw obtida e quando
uma instruo dependente pode usar o seu resultado, ento add no pode ainda ser obtida por causa
da dependncia de $t0. A instruo sub escreve em $t0, por isso no pode ser obtida antes do
add, para que add no receba um valor errado de $t0. A instruo and dependente da instruo
sub.
- Apenas a instruo sw obtida.
634
Ciclo 3
- No ciclo 3, $t0 est disponvel, ento and obtido. A instruo sub obtida
simultaneamente, porque no vai escrever em $t0 at depois do add fazer uso de $t0.
Ciclo4
- A instruo and obtida. $T0 encaminhado de sub para and.

O processador out-of-order obtm as seis instrues em quatro ciclos, para um IPC de 1,5.
A dependncia de add sobre lw por meio de $t0 um hazard de leitura aps a gravao (RAW).
A instruo add no deve ler $t0 at depois de lw ter escreveu nele. Este o tipo de dependncia
a que estamos acostumados a tratar no processador com pipeline. Inerentemente limita a velocidade
a que o programa pode ser executado, mesmo se infinitamente muitas unidades de execuo esto
disponveis. Da mesma forma, a dependncia de sw sobre o or por meio de $t3 e de and sobre
sub por meio de $T0 so dependncias RAW.
A dependncia de sub sobre and por meio de $t0 chamada de hazard de gravao aps a
leitura (WAR) ou uma anti-dependncia. A instruo sub no deve escrever em $t0 antes de add
ler $t0, de modo que add recebe o valor correto de acordo com a ordem original do programa. Os
hazard WAR no poderiam ocorrer no pipeline simples MIPS, mas podem acontecer num processador
out-of-order, se a instruo dependente (neste caso, sub) obtida muito cedo.
Um hazard WAR no essencial para o funcionamento do programa. meramente um artefato
de escolha do programador para usar o mesmo registro para duas instrues no relacionadas. Se a
instruo sub tivesse escrito $t4 em vez de $t0, as dependncias desapareceriam e sub poderia ser
obtida antes de add. A arquitetura MIPS tem apenas 32 registros, por isso, s vezes, o programador
forado a reutilizar um registro e introduzir um hazard apenas porque todos os outros registros
esto em uso.
Um terceiro tipo de hazard, no mostrado no programa, chamado de escrita depois de gravao
(WAW) ou uma dependncia de sada. Um hazard WAW ocorre se uma instruo tenta escrever um
registro aps uma instruo subsequente j ter escrito para o registro. Por exemplo, no seguinte
635
programa, tanto and como sub escrevem em $t0. O valor final no $t0 deve vir de sub de acordo
com a ordem do programa. Se um processador out-of-order tentou executar sub primeiro, um
hazard WAW pode ocorrer.
add $t0, $s1, $s2
sub $t0, $s3, $s4
Os hazard WAW tambm no so essenciais; novamente, eles so artefatos causados pelo
programador utilizando o mesmo registro para duas instrues no relacionadas. Se a instruo sub
foi obtida primeiro, o programa poderia eliminar o hazard WAW descartando o resultado do add,
em vez de escrev-lo para $t0. Isso chamado de squashing o add.
Os processadores out-of-order usam uma tabela para manter o controle das instrues de espera
de serem obtidas. A tabela, s vezes chamada de painel de avaliao, contm informaes sobre as
dependncias. O tamanho do quadro determina quantas instrues podem ser consideradas para
serem obtidas. Em cada ciclo, o processador analisa a tabela e obtm tantas instrues quantas pode,
limitadas pelas dependncias e pelo nmero de unidades de execuo (por exemplo, ALUs, portos de
memria) que esto disponveis.
O paralelismo do nvel de instruo (ILP - instruction level parallelism) o nmero de instrues
que podem ser executadas simultaneamente por um programa e microarquitetura em particular.
Estudos tericos mostram que o ILP pode ser bastante elevado para microarquiteturas out-of-order
com preditores de desvio perfeitos e um enorme nmero de unidades de execuo. No entanto, os
processadores prticos raramente conseguir um ILP maior do que 2 ou 3, mesmo com seis vias de
caminhos de dados superescalares com execuo out-of-order.
7.8.5. Renomeao de registros
Os processadores out-of-order usam uma tcnica chamada de renomeao de registro para
eliminar os hazards WAR. A renomeao de registros acrescenta alguns registros de renomeao no
arquiteturais ao processador. Por exemplo, um processador MIPS poderia acrescentar 20 registros
de renomeao, chamados de $r0 - $r19. O programador no pode usar estes registros
diretamente, porque no fazem parte da arquitetura. No entanto, o processador livre para os usar
para eliminar os hazards.
636
Por exemplo, na seo anterior, um hazard WAR ocorreu entre as instrues sub e add
baseadas na reutilizao de $t0. O processador out-of-order poderia renomear $t0para $r0 para
a instruo sub. Ento sub poderia ser executada mais cedo, porque $r0 no tem nenhuma
dependncia da instruo add. O processador mantm uma tabela que regista quais os registros
renomeados de modo que pode mudar o nome de registros consistentemente em subsequentes
instrues dependentes. Neste exemplo, $t0 tambm deve ser renomeado para $r0 na instruo
add, porque se refere ao resultado de sub.
A Figura 7.71 mostra o mesmo programa da Figura 7.70 executado por um processador out-of-
order com renomeao de registros. O $t0 renomeado para $r0 em sub e add para eliminar o
hazard WAR. As restries na obteno das instrues so descritas abaixo.
Ciclo 1
- A instruo lw obtida.
- A instruo add dependente lw por meio de $t0, por isso no pode ser ainda
obtida. No entanto, a instruo sub independente agora que seu destino foi
renomeado para $r0, de modo que sub tambm obtida.
Ciclo 2
- Lembre-se que h uma latncia de dois ciclos entre quando uma instruo lw obtida
e quando uma instruo dependente pode usar o seu resultado, ento add no pode ser
ainda obtida por causa da dependncia $t0.
- A instruo add dependente de sub, para que pode ser obtida. $r0 encaminhado
de sub para add.
- A instruo or independente, de modo que tambm obtida.
637
Figura 7.71 Execuo out-of-order de um programa utilizando renomeao de registros
Ciclo 3
- No ciclo 3, $t0 est disponvel, ento add obtida. $t3 tambm est disponvel, logo sw
obtida.
O processador out-of-order com renomeao de registros obtm as seis instrues em trs ciclos,
para um IPC de 2.
7.8.6. Instruo Simples Dados Mltiplos
O termo SIMD (pronuncia-se "sim-dee") significa single instruction multiple data, em que uma
nica instruo atua em paralelo em blocos partes de dados. Uma aplicao comum de SIMD
realizar muitas operaes aritmticas curtas de uma s vez, especialmente no processamento de
grficos. Isto tambm chamado aritmtica empacotada (packed).
638
Por exemplo, um 32-bit microprocessador pode empacotar quatro elementos de dados de 8-bits
numa palavra de 32-bits. As instrues de somar e subtrair empacotadas operam em paralelo todos
os quatro elementos de dados dentro da palavra. A Figura 7.72 apresenta uma adio de 8-bits de
soma empacotada de quatro pares de nmeros de 8-bits para produzir quatro resultados. A palavra
tambm pode ser dividida em dois elementos de 16-bits. Para realizar aritmtica empacotada
requerida a modificao da ALU para eliminar os transportes entre os elementos de dados menores.
Por exemplo, um transporte de a0 + b0 no deve afetar o resultado de a1 + b1.
Os elementos de dados curtos, muitas vezes aparecem no processamento grfico. Por exemplo,
um pixel de uma fotografia digital pode usar 8-bits para armazenar cada um dos componentes de cor
vermelho, verde e azul. Usar uma palavra de 32-bits para processar um destes componentes
desperdia os 24-bits mais significativos. Quando os componentes de quatro pixels adjacentes so
empacotados numa palavra de 32-bits, o processamento pode ser executado quatro vezes mais
rpido.
As instrues SIMD so ainda mais teis nas arquiteturas de 64-bits, o que pode empacotar oito
elementos de 8-bits, quatro elementos de 16-bits, ou dois elementos de 32-bits numa nica palavra
de 64-bits. As instrues SIMD tambm so usadas em clculos de vrgula flutuante; por exemplo,
quatro valores de 32-bits de virgula flutuante de preciso simples pode ser empacotado numa nica
palavra de 128-bits.
Figura 7.72 Aritmtica empacotada: quatro adies de 8-bits simultneas
639
7.8.7. Multithreading
Porque o ILP de programas reais tende a ser bastante baixo, a adio demais unidades de execuo
superescalar ou out-of-order d retornos decrescentes. Outro problema, discutido no Captulo 8,
que a memria muito mais lenta do que o processador. A maioria das cargas e armazenamentos
acedem a uma memria menor e mais rpida, chamado de cache. No entanto, quando as instrues
ou os dados no esto disponveis na cache, o processador pode parar 100 ou mais ciclos enquanto
obtm a informao da memria principal. Multithreading uma tcnica que ajuda a manter um
processador com muitas unidades de execuo ocupado, mesmo que o ILP de um programa seja
baixo ou o programa esteja parado espera da memria.
Para explicar o multithreading, precisamos definir alguns termos novos. Um programa em
execuo num computador chamado de processo. Os computadores podem executar vrios
processos simultaneamente; por exemplo, o leitor pode ouvir msica num PC enquanto navega na
web e executa um verificador de vrus. Cada processo consiste num ou mais threads que tambm
funcionam simultaneamente. Por exemplo, um processador de texto pode ter uma thread a lidar com
a digitao do utilizador, uma segunda thread faz a verificao da ortogrfica do documento
enquanto o utilizador trabalha, e uma terceira thread imprime o documento. Desta forma, o
utilizador no tem de esperar, por exemplo, para que um documento termine a impresso antes de
ser capaz de escrever novamente. O grau em que um processo pode ser dividido em vrias threads
que podem ser executadas simultaneamente define o seu nvel de paralelismo a nvel de thread (TLP
- thread level parallelism).
Num processador convencional, as threads s do a iluso da execuo simultaneamente. As
threads realmente se revezam sendo executadas no processador sob o controle do sistema operativo.
Quando uma thread termina a sua vez, o sistema operativo salva o seu estado de arquitetura, carrega
o estado de arquitetura da prxima thread, e comea a executar a prxima thread. Este procedimento
chamado de troca de contexto. Enquanto o processador comuta entre todas as thread com rapidez
suficiente, o utilizador tem a percepo de que todas as threads executam ao mesmo tempo.
640
Um processador multithread contm mais do que uma cpia do seu estado de arquitetura, de
modo que mais de uma thread pode estar ativa de cada vez. Por exemplo, se estendemos um
processador MIPS para ter quatro contadores de programas e 128 registros, quatro threads poderiam
estar disponveis ao mesmo tempo. Se uma thread suspensa enquanto espera pelos dados da
memria principal, o processador poderia mudar o contexto para outra thread, sem qualquer atraso,
porque o contador de programa e os registros j esto disponveis. Alm disso, se uma thread carece
de paralelismo suficiente para manter todas as unidades de execuo ocupadas, outra thread pode
ser obter instrues para as unidades ociosas.
O multithreading no melhora o desempenho de uma thread individual, porque no aumenta o
ILP. No entanto, ele melhora o rendimento geral do processador, porque vrios segmentos podem
usar recursos do processador que tm estado ociosos durante a execuo de uma nica thread.
Multithreading tambm relativamente barato de implementar, porque reproduz apenas o PC e o
banco de registros, e no as unidades de execuo e memrias.
7.8.8. Microcessadores Homogneos
Um sistema mltiprocessador consiste de mltiplos processadores e um mtodo para a
comunicao entre os processadores. Uma forma comum de multiprocessamento em sistemas de
computador o multiprocessamento homogneo, tambm chamado de multiprocessamento
simtrico (SMP - symmetric multiprocessing), em que dois ou mais processadores idnticos
compartilham uma nica memria principal.
Os mltiplos processadores pode ser chips separados ou mltiplos ncleos no mesmo chip. Os
processadores modernos tm um enorme nmero de transstores disponveis. Us-los para aumentar
a profundidade do pipeline ou para adicionar mais unidades de execuo a um processador
superescalar d pouca vantagem no desempenho e um desperdcio de energia. Por volta do ano
2005, os arquitetos computacionais fizeram uma grande mudana ao construrem vrias cpias do
processador no mesmo chip; estas cpias so chamadas ncleos.
Os Multiprocessadores podem ser usados para executar mais threads simultaneamente ou para
executar uma determinada thread mais rpido. Correr mais threads simultaneamente fcil; as
641
threads so simplesmente divididas entre os processadores. Infelizmente, os utilizadores tpicos de

PC precisam executar apenas um pequeno nmero de threads num determinado momento. A
Os cientistas em busca de sinais de execuo rpida de uma threads especfica muito mais desafiador. O programador deve dividir a
inteligncia extraterrestre usam os thread existente em vrios threads a serem executadas em cada processador. Isto torna-se
maiores cluster de multiprocessadores do complicado quando os processadores precisam se comunicar uns com os outros. Um dos principais
mundo para analisar os dados de desafios para os projetistas e programadores de computadores usar eficazmente um grande
radiotelescpios em busca de padres nmero de ncleos do processador.
que podem corresponder a sinais de vida
em outros sistemas solares. O cluster Outras formas de multiprocessamento incluem o multiprocessamento heterogneos e os clusters.
consiste em computadores pessoais Os multiprocessadores heterogneos, tambm chamados de multiprocessadores assimtricos, usam
pertencentes a mais de 3,8 milhes de microprocessadores especializados para tarefas separadas e so discutidos a seguir. No
voluntrios em todo o mundo. Quando multiprocessamento de cluster, cada processador tem seu prprio sistema de memria local.
um computador no cluster est ocioso, ele Clustering tambm se pode referir a um grupo de PC conectados em rede a executar software para
vai buscar um pedao de dados de um resolver em conjunto um grande problema.
servidor centralizado, analisa os dados e
envia os resultados de volta para o 7.8.9. Multiprocessamento Heterogneos
servidor. Voc pode oferecer o tempo Os multiprocessadores homogneos descritos na Seo 7.8.8 tem um nmero de vantagens. Eles
ocioso do seu computador para o cluster, so relativamente simples de projetar porque o processador pode ser projetado uma vez e depois
visitando setiathome.berkeley.edu. replicado vrias vezes para aumentar o desempenho. A programao para e execuo de cdigo num
multiprocessador homogneo tambm relativamente simples, pois qualquer programa pode ser
executado em qualquer processador no sistema e atingir aproximadamente o mesmo desempenho.
Infelizmente, continuar a adicionar mais e mais ncleos no garante que proporciona uma
melhoria contnua do desempenho. Em 2012, as aplicaes de consumo empregam apenas 2-3
threads em mdia, num determinado momento, e espera-se de um consumidor tpico que tenha um
par de aplicaes realmente em execuo simultaneamente. Enquanto isso suficiente para manter
os sistemas dual- e quad-core ocupados, a menos que os programas comecem a incorporar
significativamente mais paralelismo, continuar a adicionar mais ncleos para alm deste ponto
proporcionar benefcios decrescentes. Como um problema adicional, os processadores de uso geral
so projetados para proporcionar um bom desempenho mdio, e geralmente no so a opo mais
642
energeticamente eficiente para a realizao de uma determinada operao. Esta ineficincia

energtica especialmente importante em ambientes portteis com restries de energia.
Os multiprocessadores heterogneos tm como objetivo abordar estas questes atravs da
incorporao de diferentes tipos de ncleos e/ou hardware especializado num nico sistema. Cada
aplicativo usa esses recursos que proporcionam o melhor desempenho, ou relao potncia-
desempenho, para essa aplicao. Porque os transstores so bastante abundantes nos dias de hoje,
o fato de que nem todos os aplicativos iro fazer uso de cada pea de hardware a menor das
preocupaes. Os sistemas heterogneos podem tomar vrias formas. Um sistema heterogneo pode
incorporar ncleos com diferentes microarquiteturas que tm diferentes vantagens e desvantagens
de potncia, de desempenho e de rea. Por exemplo, um sistema poderia incluir ncleos simples,
superescalares out-of-order de complexidade maior. As aplicaes que podem fazer uso eficiente do
desempenho superior, mas com mais exigncia de potncia, dos ncleos out-of-order tm essa opo
disponvel para eles, enquanto que outras aplicaes que efetivamente no utilizam a computao
acrescentada podem usar os ncleos simples mais eficientes energeticamente.
Num tal sistema, todos os ncleos podem usar o mesmo ISA, a qual permite que uma aplicao
execute em qualquer um dos ncleos, ou pode empregar diferentes ISA, o que pode permitir maior
adaptao de um ncleo para uma dada tarefa. O Cell Broadband Engine da IBM um exemplo do
ltimo. O Cell incorpora um power processor element (PPE) com oito synergistic processor elements
(SPE). As SPE usam um novo ISA, a SPU ISA, que adaptado para a eficincia em cargas de trabalho
de computao intensiva. Embora vrios paradigmas de programao sejam possveis, a ideia geral
que o PPE tome a maioria das decises de controle e de gesto, tais como dividir a carga de trabalho
entre as SPE, enquanto as SPE lidam com a maioria da computao. A heterogeneidade do Cell lhe
permite fornecer muito maior desempenho computacional para uma dada potncia e rea do que
seria possvel utilizando processadores tradicionais.
Outros sistemas heterogneos podem incluir uma combinao de ncleos tradicionais e hardware
especializado. Os co-processadores de vrgula flutuante so um exemplo precoce disso. Nos primeiros
microprocessadores, no havia espao para hardware de vrgula flutuante no chip principal. Os
utilizadores interessados em ter desempenho de vrgula flutuante podem adicionar um chip
separado, que dava suporte dedicado de vrgula flutuante. Os microprocessadores de hoje incluem
643
uma ou mais unidades de vrgula flutuante em chip e agora esto comeando a incluir outros tipos
Synergistic Processor Unit (SPU) ISA. O
especializados de hardware. A AMD e a Intel ambas tm processadores que incorporam uma unidade
SPU ISA est projetado para fornecer o
de processamento grfico (GPU) ou FPGA e um ou mais ncleos x86 tradicionais no mesmo chip. O
mesmo desempenho que os
processadores de uso geral na metade da Fusion line da AMD e o Sandy Bridge da Intel o primeiro conjunto de dispositivos a incorporar um
rea e energia para determinados processador e GPU no mesmo chip. Os chips da srie E600 (Stellarton) da Intel, lanada no incio de
conjuntos de cargas de trabalho. 2011, emparelham um processador Atom com uma FPGA da Altera, novamente no mesmo
Especificamente, a SPU ISA tem como alvo dispositivo. Ao nvel do chip, um telefone celular contm um processador convencional para lidar
grficos, processamento em stream, e com a interao do utilizador, como o gerenciamento do telefone, sites de processamento e jogar
outras cargas de trabalho altamente jogos, e um processador de sinal digital (DSP) com instrues especializadas para decifrar
computacionais, como jogos fsicos e comunicaes sem fios em tempo real. Em ambientes com restries de energia, este tipo de
outras modelaes do sistema. Para hardware integrado especializado, proporciona melhores compromissos de energia-desempenho do
atingir as metas de desempenho, energia que realizar a mesma operao num ncleo standard.
e rea desejada, o ISA incorpora uma srie
de caractersticas, incluindo a execuo Os sistemas heterogneos tambm tm os seus inconvenientes. Eles acrescentam complexidade,
de 128-bits SIMD, memria gerenciado tanto em termos de concepo dos diferentes elementos heterogneos como em termos de esforo
por software, e um grande banco de adicional de programao para decidir quando e como fazer uso dos diferentes recursos. No final, os
registros. Na memria gerenciada por sistemas homogneos e heterogneos tero ambos provavelmente o seu lugar. Os
software o programador explicitamente multiprocessadores homogneos so bons para situaes, como grandes centros de dados, que tm
responsvel por mover os dados para
disponvel lotes de nveis de paralelismo de thread. Os sistemas heterogneos so bons para os casos
dentro e para fora da memria local, ao
que tm cargas de trabalho mais variadas e paralelismo limitado.
contrrio das caches dos processadores
comuns, que trazem os dados
automaticamente. Se usado 7.9. PERSPECTIVA DO MUNDO REAL: MICROARQUITETURA X86*
corretamente, isto pode economizar
energia e melhorar o desempenho porque A Seo 6.8 introduziu a arquitetura x86 usada em quase todos os PC. Esta seo segue a evoluo
os dados necessrios so trazidos dos processadores x86 atravs de microarquiteturas progressivamente mais rpidas e mais
antecipadamente e apenas quando complicadas. Os mesmos princpios que temos aplicados s microarquiteturas MIPS so usadas na
necessrio. O grande banco de registros x86.
ajuda a evitar a escassez de registros sem
a necessidade de caras renomeaes de
registros.
644
A Intel inventou o primeiro microprocessador single-chip, o 4-bit 4004, em 1971, como um

controlador flexvel para uma linha de calculadoras. Continha 2300 transstores fabricados numa tira
de 12 mm2 de silcio num processo com uma dimenso de trao de 10 m e que operava a 750 kHz.
Uma fotografia do chip obtida de um microscpio mostrada na Figura 7.3.
Em alguns lugares, colunas de quatro estruturas parecidas so visveis, como seria de esperar em
um microprocessador de 4 bits. Em torno da periferia esto as ligaes, que so utilizadas para ligar o
chip sua embalagem e placa de circuito.
O 4004 inspirou o 8008 de 8-bit, o 8080, que eventualmente evoluiu para o de 8086 de 16-bits em
1978 e o 80286 em 1982. Em 1985, a Intel lanou o 80386, que estendeu a arquitetura 8086 a 32-bits
e definiu a arquitetura x86. A Tabela 7.7 resume os principais processadores x86 da Intel. Nos 40 anos
desde o 4004, o tamanho do transstor diminuiu de 160 vezes, o nmero de transstores num chip
aumentou em cinco ordens de magnitude, e a frequncia de operao aumentou em quase quatro
ordens de magnitude. Nenhum outro campo da engenharia fez tal surpreendente progresso em to
pouco tempo.
Figura 7.73 Chip do microprocessador 4004

645
Tabela 7.7 Evoluo dos processadores Intel x86
O 80386 um processador multi-ciclo. Os componentes principais so rotulados sobre a fotografia

do chip na Figura 7.74. O caminho de dados de 32-bit claramente visvel esquerda. Cada uma das
colunas processa um bit de dados. Alguns dos sinais de controle so gerados usando microcdigo PLA
que percorre os vrios estados da FSM de controlo. A unidade de gesto de memria do lado direito
superior controla o acesso memria externa.
O 80486, mostrado na Figura 7.76, melhorou drasticamente o desempenho usando pipelining. O
caminho de dados novamente claramente visvel, juntamente com a lgica de controlo e o
microcdigo PLA. O 80486 adicionado on-chip uma unidade de vrgula flutuante; os processadores
anteriores da Intel ou enviam as instrues de vrgula flutuante para um co-processador separado ou
emulavam-nas em software. O 80486 era muito rpido para que a memria externa o pudesse
acompanhar, por isso incorporou uma cache de 8 KB no chip para manter as instrues e dados mais
comumente utilizados. O Captulo 8 descreve as caches com mais detalhes e rev os sistemas de cache
em processadores x86 da Intel.
646
647
O processador Pentium, mostrado na Figura 7.77, um processador superescalar capaz de

executar duas instrues simultaneamente. A Intel mudou para o nome Pentium, em vez de 80586
porque a AMD estava se tornando um srio concorrente vendendo alternativas ao 80486 e os
nmeros de componentes no podem ser registrados. O Pentium usa caches de instruo e dados
separadas. Ele tambm usa um preditor de branch para reduzir a penalidade no desempenho para
branchs.
O Pentium Pro, Pentium II e processadores Pentium III todos compartilham uma microarquitetura
comum out-of-order, com o nome de cdigo P6. As instrues x86 complexas so divididas numa ou
mais micro-ops semelhantes a instrues MIPS. As micro-ops so executadas num ncleo de
execuo out-of-order rpido com um pipeline de 11 estgios. A Figura 7.78 mostra o Pentium III. O
caminho de dados de 32-bit chamado de IEU (Integer Execution Unit).
Figura 7.76 Chip do microprocessador Pentium
648
Figura 7.77 Chip do microprocessador Pentium III
O caminho de dados de vrgula flutuante chamado de FPU (Floating Point Unit). O processador
tambm tem uma unidade de SIMD para executar operaes de dados short integer e de vrgula
flutuante empacotados. A poro maior do chip dedicado a obter as instrues out-of-order do que
realmente para as executar. As caches de instruo e de dados cresceram para 16 KB cada uma. O
Pentium III tambm tem uma cache de segundo nvel de 256-KB maior, mas mais lenta, no mesmo
chip.
No final dos anos 1990, os processadores foram comercializados em grande parte pela velocidade
do relgio. O Pentium 4 um outro processador out-of-order com um pipeline muito profundo para
atingir extremamente altas frequncias do relgio. Tudo comeou com 20 estgios, e verses
posteriores adoptaram 31 estgios para atingir frequncias superiores a 3 GHz. O chip, mostrado na
Figura 7.78, possui 42 a 178 milhes de transstores (dependendo do tamanho da cache), por isso
mesmo, as principais unidades de execuo so difceis de ver na fotografia. A descodificao de trs
instrues x86 por ciclo impossvel a tais velocidades de relgio elevadas porque a codificao das
649
instrues complexa e irregular. Em vez disso, o processador pre-descodifica as instrues em

simples micro-ops, em seguida, armazena as micro-ops numa memria chamada de cache de
rastreamento. As verses posteriores do Pentium 4 tambm realizavam multithreading para
aumentar o rendimento de vrias threads.
Figura 7.78 Chip do microprocessador Pentium 4
650
Figura 7.79 Chip do microprocessador Core-duo
A dependncia do Pentium 4 de pipelines profundos e alta velocidade de relgio levou a um

consumo extremamente elevado de energia, s vezes mais de 100 W. Isto inaceitvel em laptops e
faz com que a arrefecimento dos desktops seja dispendioso.
A Intel descobriu que a velha arquitetura P6 poderiam alcanar um desempenho comparvel a
muito menor velocidade de relgio e energia. O Pentium M usa uma verso melhorada da
microarquitetura P6 out-of-order com caches de instrues e dados de 32-KB e cache de segundo
nvel de 1 a 2 MB. O Core Duo um processador multi-core baseada em dois ncleos Pentium M
conectados a um cache de segundo nvel de 2-MB compartilhada. As unidades funcionais individuais
na Figura 7.79 so difceis de ver, mas os dois ncleos e a cache grande so claramente visveis.
Em 2009, a Intel lanou uma nova microarquitetura com o nome de cdigo Nehalem que agiliza a
microarquitetura Core inicial. Esses processadores, incluindo srie Core i3, i5 e i7, estendem o
conjunto de instrues para 64-bits. Eles oferecem de 2 a 6 ncleos, 3-15 MB de memria cache de
terceiro nvel, e um controlador de memria interno. Alguns modelos incluem processadores grficos
embutidos, tambm chamados de aceleradores grficos. Algum suportam "Turbo Boost" para
651
melhorar o desempenho do cdigo single-threaded, desligando os ncleos no utilizados e

aumentando a tenso e a frequncia de relgio do ncleo acelerado. Alguns oferecem
"hyperthreading", termo da Intel para 2-way multithreading, que duplica o nmero de ncleos a
partir da perspectiva do utilizador. A Figura 7.80 mostra uma bolacha de uma Core i7 com quatro
ncleos e 8-MB de cache L3 compartilhada.
Figura 7.80 Chip do microprocessador Core i7 fonte:

http://www.intel.com/pressroom/archive/releases/2008/20081117comp_sm.htm. Cortesia
Intel)
652
7.10. SUMRIO
Este Captulo descreveu trs formas de construir processadores MIPS, cada um com diferentes
compromissos de desempenho e custo. Encontramos este tema quase mgico: como pode um
dispositivo aparentemente to complicado como um microprocessador, na verdade, ser simples o
suficiente para caber num esquema de meia pgina? Alm disso, o funcionamento interno, to
misterioso para os no iniciados, so realmente razoavelmente simples.
As microarquiteturas MIPS aplicaram quase todos os tpicos abordados no texto at agora. A juno
das vrias peas da microarquitetura ilustra os princpios introduzidos nos Captulos anteriores,
incluindo o desenho de circuitos combinatrio e sequenciais, cobertos nos Captulos 2 e 3; a aplicao
de muitos dos blocos de construo descritos no Captulo 5; e a implementao da arquitetura MIPS,
apresentada no Captulo 6. As microarquiteturas MIPS podem ser descritas em poucas pginas de HDL,
utilizando as tcnicas do Captulo 4.
A construo das microarquiteturas tambm utilizou muitas das nossas tcnicas para gerenciar a
complexidade. A abstrao da microarquitetura forma o elo entre a lgica e a abstrao da arquitetura,
formando o cerne deste livro sobre projeto digital e arquitetura de computadores. Tambm usamos as
abstraes de diagramas de blocos e HDL para descrever sucintamente a disposio dos componentes.
As microarquiteturas exploraram a regularidade e modularidade, reutilizando a biblioteca de blocos de
construo comuns, como ALU, memrias, multiplexadores e registros. A hierarquia usada de vrias
maneiras. As microarquiteturas so divididas em unidades de controlo e caminho de dados. Cada uma
dessas unidades est construda a partir de blocos lgicos, que podem ser construdos a partir de
portas, que por sua vez podem ser construdos a partir de transstores, utilizando as tcnicas
desenvolvidas nos cinco primeiros Captulos.
Este Captulo comparou as arquiteturas de ciclo-nico, multi-ciclo e com pipeline para o processador
MIPS. Todos as trs microarquiteturas implementam o mesmo subconjunto do conjunto de instrues
MIPS e tm o mesmo estado de arquitetura. O processador de ciclo-nico o mais simples e tem um
CPI de 1.
653
O processador multi-ciclo usa um nmero varivel de passos mais curtos para executar as
instrues. Assim, pode reutilizar a ALU, em vez de exigir vrios somadores. No entanto, requer vrios
registros no arquiteturais para armazenar os resultados entre os estgios. O projeto multi-ciclo, em
princpio, poderia ser mais rpido, porque nem todas as instrues devem ter comprimento igual. Na
prtica, geralmente mais lento, uma vez que limitado pelos passos mais lentos e pela sobrecarga
de sequenciamento em cada passo.
O processador com pipeline, divide o processador de ciclo-nico em cinco estgios de pipeline
relativamente rpidos. Acrescenta registros de pipeline entre os estgios para separar as cinco
instrues que esto em execuo simultaneamente. E nominalmente tem um CPI de 1, mas os
hazards provocam paragens ou descartes que aumentam o CPI ligeiramente. A resoluo de alguns
hazard tambm requer hardware e design de complexidade extra. O perodo de relgio pode
idealmente ser cinco vezes mais curto do que o do processador de ciclo-nico. Na prtica, no to
curto, porque limitado pelo estgio mais lento e pela sobrecarga de sequenciamento em cada
estgio. No entanto, o pipelining fornece vantagens de desempenho substanciais. Todos os
microprocessadores modernos de alto desempenho utilizam hoje um pipeline.
Embora as microarquiteturas deste Captulo implementem apenas um subconjunto da arquitetura
MIPS, vimos que o suporte de mais instrues envolve melhorias simples do caminho de dados e do
controlador. O suporte de excees tambm requer modificaes simples.
Uma das principais limitaes deste Captulo que assumimos um sistema de memria ideal que
rpido e grande o suficiente para armazenar todo o programa e dados. Na realidade, memrias
grandes e rpidas so proibitivamente caras. O prximo Captulo mostra como obter a maioria dos
benefcios de uma memria grande e rpida com uma memria pequena e rpida que contm a
informao mais usada e uma ou mais memrias maiores, mas mais lentas, que mantenha o resto da
informao.
654
Exerccios
Exerccio 7.1 Suponha que um dos seguintes sinais de controlo do processador de ciclo-nico MIPS
tem uma falha preso-em-0, o que significa que o sinal sempre 0, independentemente do valor
pretendido. Que instrues iro funcionar mal? Porqu?
(a) RegWrite
(b) ALUOp1
(c) MemWrite
Exerccio 7.2 Repita o Exerccio 7.1, assumindo que o sinal tem uma falha preso-em-1.
Exerccio 7.3 Modifique o processador MIPS de ciclo-nico para implementar uma das seguintes
instrues. Veja o Apndice B para uma definio das instrues. Faa uma cpia da Figura 7.11 para
indicar as alteraes no caminho de dados. Nomeie quaisquer novos sinais de controle. Faa uma cpia
da Tabela 7.8 para mostrar as alteraes ao decodificador principal. Descreva quaisquer outras
mudanas que so necessrias.
(a) sll
(b) lui
(c) slti
(d) blez
655
Tabela 7.8 Tabela verdade do decodificador verdade para marcar as alteraes
Exerccio 7.4 Repita o Exerccio 7.3 para as seguintes instrues MIPS.
(a) jal
(b) lh
(c) jr
(d) srl
Exerccio 7.5 Muitas arquiteturas de processadores tm uma carga com a instruo ps-
incremento, que atualiza o registro de ndice para apontar para a prxima palavra de memria
depois de completar a carga. lwinc $rt, imm ($rs) equivalente s duas instrues a seguir:
lw $rt, imm($rs)
addi $rs, $rs, 4
Repita o Exerccio 7.3 para a instruo lwinc. possvel adicionar a instruo sem modificar
o banco de registros?
656
Exerccio 7.6 Adicione uma unidade de vrgula flutuante ao processador de ciclo-nico MIPS para
lidar com add.s, sub.s e mul.s. Suponha que tem disponveis unidades somador e multiplicador
de vrgula flutuante de preciso simples. Explique que mudanas devem ser feitas ao caminho de
dados e ao controlador.
Exerccio 7.7 A sua amiga uma expert no projeto de circuitos. Ela se ofereceu para redesenhar
uma das unidades do processador de ciclo-nico MIPS para ter metade do atraso. Usando os atrasos
da Tabela 7.6, em que unidade deve ela trabalhar para obter o maior aumento de velocidade do
processador, em geral, e qual deve ser o tempo de ciclo da mquina melhorado?
Exerccio 7.8 Considere os atrasos apresentados na Tabela 7.6. Ben Bitdiddle construiu um
somador prefix que reduz o atraso da ALU em 20 ps. Se o outro elemento permanece o mesmo,
encontre o novo tempo de ciclo do processador de ciclo-nico MIPS e determine quanto tempo leva
para executar um benchmark com 100 bilhes de instrues.
Exerccio 7.9 Suponhamos que um dos seguintes sinais de controlo do processador multi-ciclo de
MIPS tem uma falha preso-em-0, o que significa que o sinal sempre 0, independentemente do valor
pretendido. Que instrues iriam funcionar mal? Porqu?
(a) MemtoReg
(b) ALUOp0
(c) PCSrc
Exerccio 7.10 Repita o Exerccio 7.9, assumindo que o sinal tem uma falha preso-em-1.
657
Exerccio 7.11 Modifique o cdigo HDL para o processador de ciclo-nico MIPS, dado na Seo
7.6.1, para lidar com uma das novas instrues do Exerccio 7.3. Melhore o
o testbench, apresentados na Seo 7.6.3, para testar a nova instruo.
Exerccio 7.12 Repita o Exerccio 7.11 para as novas instrues do Exerccio 7.4.
Exerccio 7.13 Modifique o processador multi-ciclo MIPS para implementar uma das
seguintes instrues. Veja o Apndice B para uma definio das instrues. Faa
uma cpia da Figura 7.27 para indicar as alteraes no caminho de dados. Nomeie quaisquer novos
sinais de controle. Faa uma cpia da Figura 7.39 para mostrar as alteraes ao controlador FSM.
Descreva quaisquer outras mudanas que so necessrias.
(a) srlv
(b) ori
(c) xori
(d) jr
Exerccio 7.14 Repita o Exerccio 7.13 para as seguintes instrues MIPS.
(a) bne
(b) lb
(c) lbu
(d) andi
658
Exerccio 7.15 Repita o Exerccio 7.5 para o processador multi-ciclo MIPS. Mostre as alteraes ao
caminho de dados multi-ciclo e ao controlar FSM. possvel adicionar a instruo sem modificar o
banco de registros?
Exerccio 7.16 Repita o Exerccio 7.6 para o processador multi-ciclo MIPS.
Exerccio 7.17 Suponha que o somador de vrgula flutuante e o multiplicador do Exerccio 7.16, leva
cada um dois ciclos para operar. Por outras palavras, as entradas so aplicadas no incio de um ciclo, e
a sada est disponvel no segundo ciclo. Como a sua resposta ao Exerccio 7.16 muda?
Exerccio 7.18 A sua amiga, a expert em projeto de circuito, ofereceu-se para redesenhar uma das
unidades do processador multi-ciclo MIPS para o tornar muito mais rpido. Usando os atrasos da
Tabela 7.6, que unidade ela deve trabalhar para obter o maior aumento de velocidade do processador?
O quo rpido ele deve ser? (Tornando-o mais rpido do que o necessrio um desperdcio de esforo
do seu amigo.) Qual o tempo de ciclo do processador melhorado?
Exerccio 7.19 Repita o Exerccio 7.8 para o processador multi-ciclo. Considere a instruo mix do
Exemplo 7.7.
Exerccio 7.20 Suponha que o processador multi-ciclo MIPS tem os atrasos dos componentes
indicados na Tabela 7.6. Alyssa P. Hacker projecta um novo banco de registros que tem 40% menos
energia, mas tem o dobro do atrado. Ser que ela deveria mudar para o banco de registros baixa
potncia mais lento para o seu processador multi-ciclo?
659
Exerccio 7.21 A Goliath Corp afirma ter uma patente sobre um banco de registros de trs portos.
Em vez de desafiar a Goliath no tribunal, Ben Bitdiddle projeta um novo banco de registros que tem
apenas uma nica porta de leitura/escrita (como a memria combinada de instruo e de dados).
Redesenhe o caminho de dados multi-ciclo MIPS e o controlador para usar o seu novo banco de
registros.
Exerccio 7.22 Qual o CPI do processador multi-ciclo MIPS redesenhado a partir do Exerccio
7.21? Use a instrues mix do Exemplo 7.7.
Exerccio 7.23 Quantos ciclos so necessrios para executar o seguinte programa no

processador multi-ciclo MIPS? Qual o CPI deste programa?
addi $s0, $0, done # result = 5
while:
beq $s0, $0, done # if result > 0, execute while block
addi $s0, $s0, -1 # while block: result = result-1
j while
done:
Exerccio 7.24 Repita o Exerccio 7.23 para o programa seguinte.

add $s0, $0, $0 # i = 0
add $s1, $0, $0 # sum = 0
addi $t0, $0, 10 # $t0 = 10
loop:
660
slt $t1, $s0, $t0 # if (i < 10), $t1 = 1, else $t1 = 0

beq $t1, $0, done # if $t1 == 0 (i >= 10), branch to done
add $s1, $s1, $s0 # sum = sum + i
addi $s0, $s0, 1 # increment i
j loop
done:
Exerccio 7.25 Escreve o cdigo HDL para o processador multi-ciclo MIPS. O processador deve ser
compatvel com o mdulo de nvel superior seguinte. O mdulo de mem usado para manter as
instrues e os dados. Teste o seu processador usando o testbench da Seo 7.6.3.
module top(input logic clk, reset,
output logic [31:0] writedata, adr,
output logic memwrite);
logic [31:0] readdata;
// instantiate processor and memories

mips mips(clk, reset, adr, writedata, memwrite, readdata);
mem mem(clk, memwrite, adr, writedata, readdata);
endmodule
module mem(input logic clk, we,
input logic [31:0] a, wd,
output logic [31:0] rd);
logic [31:0] RAM[63:0];
initial
661
begin
$readmemh("memfile.dat", RAM);
end
assign rd = RAM[a[31:2]]; // word aligned
if (we)
RAM[a[31:2]] <= wd;
endmodule
Exerccio 7.26 Estenda o seu cdigo HDL para o processador multi-ciclo MIPS do Exerccio 7.25
para lidar com uma das novas instrues do Exerccio 7.13. Melhore a testbench para testar a nova
instruo.
Exerccio 7.27 Repita o Exerccio 7.26 para uma das novas instrues do Exerccio 7.14.
Exerccio 7.28 O processador com pipeline MIPS est a executar o seguinte programa. Quais os
registros que esto a ser escritos e quais o que esto a ser lidos no quinto ciclo?
addi $s1, $s2, 5
sub $t0, $t1, $t2
lw $t3, 15($s1)
sw $t5, 72($t0)
or $t2, $s4, $s5
662
Exerccio 7.29 Repita o Exerccio 7.28 para o seguinte programa MIPS. Lembre-se que o
processador com pipeline MIPS tem uma unidade de hazard.
add $s0, $t0, $t1
sub $s1, $t2, $t3
and $s2, $s0, $s1
or $s3, $t4, $t5
slt $s4, $s2, $s3
Exerccio 7.30 Usando um diagrama semelhante ao da Figura 7.52, mostre o encaminhamento e o

stall necessrio para executar as seguintes instrues no processador com pipeline MIPS.
add $t0, $s0, $s1
sub $t0, $t0, $s2
Iw $t1, 60($t0)
and $t2, $t1, $t0
Exerccio 7.31 Repita o Exerccio 7.30 para as seguintes instrues.

add $t0, $s0, $s1
Iw $t1, 60($s2)
sub $t2, $t0, $s3
and $t3, $t1, $t0
Exerccio 7.32 Quantos ciclos so necessrios para o processador com pipeline MIPS obter todas as
instrues do programa no Exerccio 7.23? Qual o CPI do processador neste programa?
663
Exerccio 7.33 Repita o Exerccio 7.32 para as instrues do programa no Exerccio 7.24.
Exerccio 7.34 Explique como estender o processador com pipeline MIPS para suportar a instruo
addi.
Exerccio 7.35 Explique como estender o processador com pipeline para suportar a instruo j.
D especial ateno forma como o pipeline descartado quando um salto ocorre.
Exerccio 7.36 Os exemplos 7.9 e 7.10 afirmam que o desempenho do processador com pipeline
MIPS pode ser melhorado se os branchs ocorrem na fase de execuo, em vez de no estgio de
decodificao. Mostre como modificar o processador com pipeline da Figura 7.58 para que o branch
ocorra no estgio de execuo. Como que os sinais de stall e de flushs se alteram? Refazer os
Exemplos 7.9 e 7.10 para encontrar o novo CPI, tempo de ciclo e o tempo total para executar o
programa.
Exerccio 7.37 A sua amiga, a expert em projeto de circuitos, ofereceu-se para redesenhar uma
das unidades do processador com pipeline MIPS para ser muito mais rpido. Usando os atrasos da
Tabela 7.6 e o Exemplo 7.10, que unidade, ela deve trabalhar para obter o maior aumento de
velocidade do processador? o quo rpido ele deve ser? (Tornando-o mais rpido do que o necessrio
um desperdcio de esforo do seu amigo.) Qual o tempo de ciclo do processador melhorado?
664
Exerccio 7.38 Considere os atrasos da Tabela 7.6 e o Exemplo 7.10. Agora, suponha que a ALU era
20% mais rpida. Ser que o tempo de ciclo do processador com pipeline MIPS mudou? E se a ALU for
20% mais lenta?
Exerccio 7.39 Suponha que o processador com pipeline MIPS dividido em 10 estgios de 400 ps
cada, incluindo a sobrecarga de sequenciamento. Considere a instrues mix do Exemplo 7.7. Tambm
considere que 50% das cargas so imediatamente seguidas por uma instruo que utiliza o resultado,
requerendo seis stalls, e que 30% dos branchs tm um erro de previso. O endereo de destino de
instrues branch ou de salto no determinado at ao final do segundo estgio. Calcule o tempo
mdio do CPI e de execuo da computao 100 bilhes de instrues da referncia SPECint2000 para
este processador com pipeline de 10-estgios.
Exerccio 7.40 Escreva o cdigo HDL para o processador com pipeline MIPS. O processador deve ser
compatvel com o mdulo de alto nvel do Exemplo HDL 7.13. Deve suportar todas as instrues
descritas neste Captulo, incluindo addi e j (ver Exerccio 7.34 e Exerccio 7.35). Teste o seu projeto
usando o testbench do Exemplo HDL 7.12.
Exerccio 7.41 Projete a unidade hazard mostrada na Figura 7.58 para o processador com pipeline
MIPS. Use HDL para implementar o seu projeto. Esboce o hardware que uma ferramenta de sntese
possa gerar a partir de seu HDL.
Exerccio 7.42 A interrupo nonmaskable (NMI) desencadeada por um pino de entrada para o
processador. Quando o pino ativado, a instruo atual deve terminar, ento o processador deve
definir o registro Cause a 0 e assumir uma exceo. Mostre como modificar o processador multi-ciclo
das Figura 7.63 e Figura 7.64 para lidar com interrupes nonmaskable.
665
Os exerccios seguintes apresentam perguntas que foram feitas em entrevistas para trabalhos de
projeto digital.
Pergunta 7.1 Explique as vantagens de microprocessadores com pipeline.
Pergunta 7.2 Se os estgios adicionais de pipeline permitem que um processador possa ser mais
rpido, por que no tm os processadores 100 estgios de pipeline?
Pergunta 7.3 Descreva o que um hazard num microprocessador e explique as formas pelas quais
ele pode ser resolvido. Quais so os prs e contras de cada alternativa?
Pergunta 7.4 Descrever o conceito de um processador superescalar e os seus prs e contras.
666
8. Memria e Sistemas de I/O
8.1. INTRODUO
A capacidade de um computador para resolver problemas influenciada pelo seu sistema de memria e
pelos dispositivos entrada/sada (I/O input/output) tais como monitores, teclados e impressoras que nos
permitem manipular e ver os resultados das suas computaes. Este Captulo investiga esses sistemas prticos
de memria e I/O.
A performance de um sistema computacional depende do sistema de memria bem como da
microarquitetura do processador. O Captulo 7 sups um sistema de memria ideal que poderia ser acessado
num nico ciclo de relgio. No entanto, isso seria verdade apenas para uma memria muito pequena ou um
processador muito lento! Os primeiros processadores eram relativamente lentos, ento a memria era capaz
de o acompanhar. Mas a velocidade dos processadores aumentou a uma taxa maior do que a velocidade das
memrias. Memrias DRAM so, atualmente, de 10 a 100 vezes mais lentas do que processadores. O crescente
distanciamento entre as velocidades do processador e da memria DRAM demanda sistemas de memria cada
vez mais engenhosos para tentar aproximar uma memria que seja to rpida quanto o processador. A primeira
metade deste Captulo investiga os sistemas de memria e considera as escolhas em relao velocidade,
capacidade e ao custo.
O processador comunica com o sistema de memria atravs de uma interface de memria. A Figura 8.1
mostra uma simples interface de memria utilizada no nosso processador MIPS multi-ciclos. O processador
envia um endereo atravs do barramento de endereos para o sistema de memria. Para uma leitura,
MemWrite 0 e a memria retorna o dado no barramento ReadData. Para uma escrita, MemWrite 1 e o
processador envia dados para a memria atravs do barramento WriteData.
667
Captulo oito Memria e Sistemas de I/O
Figura 8.1 A interface de memria
Os principais problemas em projetos de sistemas de memria podem ser explicados utilizando uma
metfora de livros numa biblioteca. Uma biblioteca contm muitos livros nas estantes. Se voc estivesse
escrevendo um trabalho de concluso de curso sobre o significado dos sonhos, voc poderia ir at
biblioteca e tirar da estante o livro de Freud, A Interpretao dos Sonhos, e traz-lo at o seu cubculo. Aps
passar os olhos sobre ele, voc o colocaria de volta e pegaria A Psicologia do Inconsciente, de Jung. Voc
poderia ento voltar para pegar outra citao de Interpretao dos sonhos, seguida por outra viagem nas
estantes atrs de O Ego e o Id. Logo voc ficaria cansado de ficar caminhando do seu cubculo at s estantes.
Se voc for esperto, economizaria tempo mantendo os livros no seu cubculo ao invs de ficar carregando-
os de um lado para o outro. Alm disso, quando voc pega um livro de Freud, voc poderia tambm pegar
vrios outros de seus livros da mesma estante.
Esta metfora enfatiza o princpio, introduzido na Seo 6.2.1 de fazer o caso comum, rpido. Mantendo
os livros que voc usou recentemente ou gostaria de usar no futuro em seu cubculo, voc reduz o nmero
de idas consumidoras de tempo s estantes. Em particular, voc utiliza os princpios da localidade espacial
e temporal. Localidade temporal significa que, se voc utilizou um livro recentemente, provvel que voc
o usar novamente em breve. Localidade espacial significa que quando voc utiliza um livro em particular,
voc provavelmente ir se interessar por outros livros da mesma estante.
A biblioteca em si faz o caso comum rpido atravs do uso desses princpios e localidade. A biblioteca
no tem nem o espao nas prateleiras, e nem o oramento para acomodar todos os livros do mundo. Ao
668
invs disso, ela mantm alguns dos livros menos utilizados armazenados no poro. Alm disso, ela pode ter
um acordo entre bibliotecas prximas de modo que ela possa oferecer mais livros do que possui fisicamente.
Resumindo, voc obtm benefcios tanto de uma grande coleo, quanto do rpido acesso aos livros mais
comumente utilizados atravs de uma hierarquia de armazenamento. Os livros mais comumente utilizados
esto no seu cubculo. Uma grande coleo est nas estantes. E uma coleo ainda maior est disponvel,
com aviso prvio, na cave e em outras bibliotecas. Similarmente, sistemas de memria usam uma hierarquia
de armazenamento para acessar rapidamente os dados mais comumente utilizados enquanto ainda
possuem a capacidade de armazenar grandes quantidades de dados.
Os subsistemas de memria utilizados para construir essa hierarquia foram introduzidos na Seo 5.5. As
memrias de computador so primariamente construdas a partir de RAM dinmicas (DRAM) e RAM
estticas (SRAM). Idealmente, o sistema de memria do computador rpido, grande e barato. Na prtica,
uma nica memria possui apenas dois desses trs atributos: ou lenta, ou pequena, ou cara. Porm,
os sistemas computacionais podem-se aproximar do ideal pela combinao de uma memria rpida,
pequena e barata, com uma memria lenta, grande e barata. A memria rpida armazena os dados e as
instrues mais comumente utilizadas, assim, em mdia, o sistema de memria aparentar ser rpido. A
memria grande armazena os restantes dados e instrues, ento a capacidade do sistema como um todo
grande. A combinao de duas memrias baratas muito menos cara do que uma nica memria rpida.
Esses princpios so estendidos para o uso em toda uma hierarquia de memorias para aumentar a
capacidade e diminuir a velocidade.
As memrias dos computadores so geralmente construdas a partir de chips DRAM. Em 2012, um PC
tpico possua a memria principal consistindo de 4 a 8 GB de DRAM, e a memria DRAM custa cerca de
$10 por gigabyte (GB). Os preos da DRAM tm diminudo cerca de 25% ao ano durante as ltimas trs
dcadas, e a capacidade de memria vm crescendo mesma taxa, de modo que o custo total da memria
num PC tem permanecido grosseiramente constante. Infelizmente, a velocidade das DRAM vem
aumentando apenas cerca de 7% ao ano, enquanto a performance de um processador aumenta cerca de
25% a 50% ao ano, como mostrado na Figura 8.2. O grfico mostra as velocidades das memrias (DRAM) e
dos processadores, tendo como referncia as velocidades do ano de 1980. Em meados de 1980, as
velocidades dos processadores e das memrias eram iguais. Mas as performances vm divergindo desde
ento, com as memrias ficando seriamente atrasadas.
669
Figura 8.2 Divergncia entre desempenho do processador e da memria - Adaptada com a permisso de
Hennessy e Patterson, Computer Architecture: A Quantitative Approach, 5th ed, Morgan Kaufmann, 2012
A DRAM poderia acompanhar os processadores nos anos 1970 e no incio dos anos 1980, mas atualmente
lamentavelmente lenta. O tempo de acesso DRAM de uma a duas ordens de magnitude maior do que o
tempo de ciclo do processador (dezenas de nano segundos, comparado com menos do que um nano
segundo).
Para contrariar esta tendncia, os computadores armazenam os dados e instrues mais comumente
utilizados numa memria rpida, porm menor, chamada cache. A cache , usualmente, construda fora da
SRAM, no mesmo chip que o processador. A velocidade da cache comparvel velocidade do processador,
pois a SRAM inerentemente mais rpida do que a DRAM, e porque a memria no mesmo chip elimina os
longos atrasos causados pelo caminho at um chip separado. Em 2012, um chip SRAM custava na ordem de
$10,000/GB, porm a cache relativamente menor (kilobytes a alguns megabytes), ento o custo total
pequeno. Caches podem armazenar tanto instrues quanto dados, mas iremos nos referir ao seu contedo
como sendo, genericamente, dados.
Se o processador solicita dados que esto disponveis na cache, eles so retornados rapidamente. Isso
chamado cache hit. Caso contrrio, o processador recupera o dado da memria principal (DRAM). Isso
670
chamado cache miss. Se acontecem hits na maioria do tempo, ento o processador raramente tem que
esperar pela memria principal lenta, e o tempo mdio de acesso curto.
O terceiro nvel na hierarquia de memria o disco rgido. Do mesmo modo que uma biblioteca utiliza a
cave para armazenar os livros que no cabem nas estantes, os sistemas computacionais utilizam o disco rgido
para armazenar dados que no so cabem na memria principal. Em 2012, uma drive de disco rdigo (HDD
Hard Disk Drive), construdo utilizando armazenamento magntico, custava menos que $0,10/GB e possua
um tempo de acesso de cerca de 10 ms. O custo dos discos rgidos tem diminudo cerca de 60% ao ano, mas
o tempo de acesso quase no melhorou. As drives de estado slido (Solid State Drives SSD), construdos
utilizando tecnologia de memria flash, so uma alternativa comumente crescente aos HDD. Os SSD vm
sendo utilizados por nichos de mercado por mais de duas dcadas, e foram introduzidos no mercado principal
em 2007. Os SSD superam algumas das falhas mecnicas dos HDD, mas custam dez vezes mais, $1/GB.
O disco rgido fornece uma iluso de mais capacidade do que na verdade existe na memria principal. Isso
, ento, chamado memria virtual. Assim como livros numa cave, os dados na memria virtual levam um
longo tempo para serem acessados. A memria principal, tambm chamada memria fsica, mantm um
subconjunto de memria virtual. Consequentemente, a memria principal pode ser vista como uma cache
para os dados mais comumente utilizados do disco rgido.
Figura 8.3 Uma hierarquia de memria tpica
A Figura 8.3 resume a hierarquia de memria de um sistema computacional discutida no restante deste
Captulo. O processador primeiramente procura o dado na pequena, mas rpida, cache, que est localizada,
671
usualmente, no mesmo chip. Se o dado no est disponvel na cache, o processador ento procura na
memria principal. Se o dado tambm no est l, o processador busca o dado na memria virtual do grande,
porm lento, disco rgido. Figura 8.4 ilustra esse compromisso entre a capacidade e a velocidade na hierarquia
de memria, e lista os custos tpicos, tempos de acessos e larguras de banda na tecnologia em 2012.
medida que o tempo de acesso diminui, a velocidade aumenta.
A Seo 8.2 introduz a anlise de performance do sistema de memria. A Seo 8.3 explora vrias
organizaes de cache, e a Seo 8.4 investiga os sistemas de memria virtual. Para concluir, este Captulo
explora como os processadores conseguem acessar dispositivos de entrada e sada, como teclados e
monitores, de maneira muito parecida com a qual acessam a memria. A Seo 8.5 investiga o I/O mapeado
na memria. A Seo 8.6 enderea o I/O para sistemas embarcados, e a Seo 8.7 descreve os principais
padres I/O para computadores pessoais.
Figura 8.4 Componentes da hierarquia de memria, com caractersticas tpicas em 2012
8.2. ANLISE DA PERFORMANCE DOS SISTEMAS DE MEMRIA

Projetistas (e compradores de computadores) precisam de meios quantitativos para medir a performance
de sistemas de memria, para avaliar o custo-benefcio entre vrias alternativas. As mtricas da performance
dos sistemas de memria so a hit rate, a miss rate, e o tempo mdio de acesso memria. As taxas de hit e
miss so calculadas como:
672

= = 1 (8.1)

= = 1

Exemplo 8.1 CALCULANDO A PERFORMANCE DA CACHE
Suponha que um programa tem 2000 instrues de acesso de dados (carregamentos ou armazenamentos),
e 1250 desses valores de dados solicitados so encontrados na cache. Os outros 750 valores de dados so
fornecidos ao processador pela memria principal ou memria de disco. Quais so a hit rate e miss rate para a
cache?
Soluo: A miss rate 750/2000 = 0.375 = 37.5%. A hit rate 1250/2000 = 0.625 = 1 0.375 = 62.5%.
O tempo mdio de acesso memria (AMAT Average memory access time) o tempo mdio que o
processador deve esperar pela memria por instruo de carregamento ou armazenamento. No sistema
computacional tpico da Figura 8.3, o processador primeiramente procura pelo dado na cache. Se a cache falha,
o processador ento procura na memria principal. Se a memria principal falha, o processador acessa a
memria virtual no disco rgido. Portanto, o AMAT calculado como:
= + ( + ) (8.2)
Onde , e so os tempos de acesso da cache, memria principal e memria virtual, e
e so as taxas de erro da cache e da memria principal, respectivamente.
Exemplo 8.2 CALCULANDO O TEMPO MDIO DE ACESSO MEMRIA

Suponha que um sistema computacional possui uma organizao de memria com apenas dois nveis de
hierarquia, a cache e a memria principal. Qual o tempo mdio de acesso memria, dados os tempos de
acessos e miss rate na Tabela 8.1?
673
Soluo: O tempo mdio de acesso memria de 1 + 0.1(100) = 11 ciclos.
Tabela 8.1 Tempos de acesso e taxas de erro
Exemplo 8.3 MELHORANDO O TEMPO DE ACESSO
Gene Amdahl, 1922-. Famoso

Um tempo mdio de acesso memria de 11 ciclos significa que o processador gasta dez ciclos esperando pelo
pela Lei de Amdahl, uma dado para cada ciclo verdadeiramente usando o dado. Qual a miss rate da cache necessria para reduzir o tempo
observao feita por ele em 1965. mdio de acesso memria para 1,5 ciclos, dados os tempos de acesso na Tabela 8.1?
Enquanto estava na graduao,
Soluo: Se a miss rate , o tempo mdio de acesso de 1 + 100. Ajustando esse tempo para 1,5 e resolvendo
comeou a projetar
para requer uma miss rate da cache de 0,5%.
computadores em seu tempo
livre. Esse trabalho paralelo Como uma palavra de cautela, melhoras na performance podem no ser sempre to boas quanto parecem. Por
rendeu seu Ph.D em fsica terica, exemplo, fazendo um sistema de memria dez vezes mais rpido no necessariamente far um programa de
em 1952. Se juntou IBM
computador rodar dez vezes mais rpido. Se 50% das instrues de um programa so carregamentos e
imediatamente aps a
armazenamentos, uma melhora de dez vezes no sistema de memria apenas significa uma melhora de 1.82 vezes
graduao, e depois saiu para
fundar trs companhias, inclusive na performance do programa. Este princpio geral chamado Lei de Amdahl, a qual diz que o esforo gasto
a Amdhal Corporation, em 1970 aumentando a performance de um subsistema vlido apenas se o subsistema afeta uma grande percentagem
da performance como um todo.
8.3.CACHES
A cache mantm dados comumente utilizados pela memria. O nmero de dados que podem ser mantidos
chamado de capacidade, . Devido capacidade da cache ser menor do que a da memria principal, o projetista
do sistema computacional deve escolher em qual subconjunto da memria principal ser mantida a cache.
674
Quando o processador tenta acessar um dado, ele primeiro verifica na cache pelo dado. Se a cache acerta, o
dado est disponvel imediatamente. Se a cache erra, o processador busca o dado na memria principal e o coloca
na cache para uso futuro. Para acomodar novos dados, a cache deve substituir dados antigos. Esta seo investiga
esses problemas no projeto da cache respondendo as seguintes questes: (1) Que dado mantido na cache? (2)
Como o dado encontrado? E (3) Que dado substitudo para abrir espao para o novo dado quando a cache
est cheia?
Quando ler as prximas sees, tenha em mente que a fora motriz para responder essas questes a Cache: Um local escondido,
principalmente para ocultar e
inerente localizao temporal e espacial do acesso aos dados na maioria das aplicaes. A cache utiliza localizao
preservar provises ou
espacial e temporal para prever qual dado ser necessitado em seguida. Se um programa acessa o dado numa
implementos.
ordem aleatria, ele no se beneficiaria da cache.
-Merriam Webster Online Dictionary.
Como explicaremos nas sees seguintes, as caches so especificadas por sua capacidade (C), nmero de 2012
conjuntos (S), tamanho de bloco (b), nmero de blocos (B), e grau de associatividade (N).
Apesar de focarmos o carregamento de dados na cache, os mesmos princpios se aplicam para as buscas em
cache de instrues. As operaes de armazenamento de dados em cache so similares e sero melhor discutidas
na Seo 8.3.4.
8.3.1. Qual a Informao a Manter na Cache?
Uma cache ideal anteciparia todos os dados necessrios ao processador e os buscaria na memria principal
antes do tempo, de modo que a cache teria uma miss rate nulo. Devido ao fato de que impossvel prever o
futuro com perfeita acurcia, a cache deve supor qual o dado ser necessrio baseado em um padro passado
de acessos memria. Em particular, a cache explora a localidade temporal e espacial para alcanar uma miss
rate pequeno.
Lembre-se que localidade temporal significa que, o processador tem a tendncia de acessar um pedao de
dado novamente em breve, se ele tiver acessado aquele dado recentemente. Portanto, quando o processador
carrega ou armazena dados que no esto na cache, o dado copiado da memria principal para a cache.
Requisies subsequentes para aquele dado iro direto para a cache.
675
Lembre-se que localidade espacial significa que, quando o processador acessa um pedao de dado,
provvel que ele tambm acesse dados em posies de memria prximas. Portanto, quando a cache busca
uma palavra na memria, ele tambm buscar vrias palavras adjacentes. Esse grupo de palavras chamado
bloco de cache ou linha de cache. O nmero de palavras no bloco de cache, , chamado tamanho de bloco.
Uma cache de capacidade contm = / blocos.
Os princpios da localidade temporal e espacial tm sido experimentalmente verificados em programas
reais. Se uma varivel utilizada num programa, a mesma varivel provavelmente ser utilizada depois,
criando localidade temporal. Se um elemento em um array utilizado, outros elementos no mesmo array
tambm tm a tendncia a serem utilizados, criando localidade espacial.
8.3.2. Como a Informao Encontrada?
A cache organizado em conjuntos, cada um deles mantendo um ou mais blocos de dados. A relao
entre o endereo do dado na memria principal e a localizao daquele dado na cache chamada de
mapeamento. Cada endereo de memria mapeia para exatamente um conjunto na cache. Alguns dos bits
de endereo so utilizados para determinar qual o conjunto da cache que contm o dado. Se o conjunto
contm mais de um bloco, o dado pode ser mantido em qualquer um dos blocos do conjunto.
As caches so categorizadas tendo por base o nmero de blocos num conjunto. Numa cache de
mapeamento direto, cada conjunto contm exatamente um bloco, ento a cache contm = conjuntos.
Ento, um endereo particular da memria principal mapeia para um nico bloco a cache. Numa cache de
conjunto associativa de N-vias, cada conjunto contm blocos. O endereo continua a mapear apenas um
nico conjunto, com = / conjuntos. Mas o dado daquele endereo pode ir para qualquer um dos
blocos naquele conjunto. Uma cache totalmente associativa possui apenas um conjunto = 1. O dado pode
ir para qualquer um dos blocos no conjunto. Consequentemente, uma cache totalmente associativa outro
nome para uma cache associativa de -vias.
Para ilustrar essas organizaes de cache, iremos considerar um sistema de memria MIPS com endereos
de 32-bits e palavras de 32-bits. A memria enderevel por byte, e cada palavra possui quatro bytes, ento,
a memria consiste de 230 palavras alinhadas nos limites das palavras. Analisamos caches com uma
capacidade de oito palavras (), em nome da simplicidade. Comearemos com um bloco de uma palavra de
tamanho (), de seguida generalizaremos para blocos maiores.
676
Cache de Mapeamento Direto

Uma cache de mapeamento direto possui um bloco em cada conjunto, logo organizada em =
conjuntos. Para entender o mapeamento dos endereos de memria para os blocos de cache, imagine a
memria principal como sendo mapeada em blocos de palavras, assim como a cache o . Um endereo no
bloco 0 da memria principal mapeia para o conjunto 0 da cache, e, assim por diante, at o endereo no
bloco 1 da memria principal mapear o bloco 1 da cache. No existem mais blocos na cache, ento
o mapeamento a envolve de modo que o bloco da memria principal mapeia para o bloco 0 da cache.
Esse mapeamento ilustrado na Figura 8.5 para uma cache de mapeamento direto com a capacidade de
oito palavras e um bloco de tamanho de uma palavra. A cache possui oito conjuntos, cada um deles contendo
um bloco de uma palavra. Os dois bits mais baixos do endereo so sempre 00, pois eles so de palavras
alinhadas. Os prximos log 2 8 = 3 bits indicam o conjunto para o qual mapeado cada endereo de
memria. Ento, os dados nos endereos 000000004, 000000024, , 04 so mapeados
para o conjunto 1, como mostrado em azul. Da mesma forma, dados nos endereos
000000010, , 00 so todos mapeados para o conjunto 4, e assim por diante. Cada endereo
da memria principal mapeia exatamente um conjunto na cache.
Exemplo 8.4 CAMPOS DE CACHE

Para qual conjunto da cache na Figura 8.5 a palavra no endereo 000000014 mapeada? Nomeie outro
endereo que mapeia para o mesmo conjunto.
Soluo: Os dois bits menos significativos dos endereos so 00, pois os endereos so de palavras
alinhadas. Os prximos trs bytes so 101, ento a palavra mapeia para o conjunto 5. Palavras nos
endereos 034, 054, 074, , 04 so todas mapeadas para o mesmo conjunto.
Devido a muitos endereos mapearem para um nico conjunto, a cache deve tambm acompanhar o
endereo dos dados efetivamente contidos em cada conjunto. Os bits menos significativos do endereo
especificam quais conjuntos mantm os dados. Os bits mais significativos restantes so chamados de tag e
indicam quais dos muitos possveis endereos so mantidos naquele conjunto.
677
Em nossos exemplos anteriores, os dois bits menos significativos do endereo de 32-bits so chamados
byte offset, pois eles indicam o byte no interior da palavra. Os prximos trs bits so chamados set bits, pois
eles indicam o conjunto para o qual o endereo mapeado (em geral, o nmero de set bits log 2 ). Os 27
tag bits restantes indicam o endereo de memria do dado armazenado num dado conjunto da cache. A
Figura 8.6 mostra os campos de cache para o endereo 04. Ele mapeia para o conjunto 1 e todas
as suas tags so 1.
Figura 8.5 Mapeamento da memria principal para uma cache de mapeamento direto
678
Exemplo 8.5 CAMPOS DE CACHE

Encontre o nmero do conjunto e os tag bits para uma cache de mapeamento direto com 1024 (210 )
conjuntos e tamanho de bloco de uma palavra. O tamanho do endereo de 32-bits.
Soluo: Uma cache com 210 conjuntos necessita log 2 (210 ) = 10 set bits. Os dois bits menos significativos do
endereo so o byte offset, e os 32 10 2 = 20 bits restantes formam o tag.
Algumas vezes, como quando o computador ligado, os conjuntos da cache no contm dados. A cache
utiliza um bit vlido para cada conjunto para indicar se o conjunto mantm dados significativos. Se o bit vlido
0, o contedo no tem significado.
Figura 8.6 Campo de cache para o endereo 0xFFFFFFE4, quando mapeado para a cache na Figura 8.5
A Figura 8.7 mostra o hardware para a cache diretamente mapeada da Figura 8.5. A cache construda
como uma SRAM de oito entradas. Cada entrada, ou conjunto, contm uma linha consistindo de 32-bits de
dados, 27-bits de tag, e 1-bit vlido. A cache acessada utilizando o endereo de 32-bits. Os dois bits menos
significativos, os bits do byte de offset, so ignorados para o acesso das palavras. Os prximos trs bits, os set
bits, especificam a entrada ou o conjunto na cache. Uma instruo de carregamento l a entrada especificada
da cache e verifica os tag bits e bits vlidos. Se o tag est em concordncia com os 27-bits mais significativos
do endereo, e o bit vlido 1, a cache acerta e o dado retornado ao processador. Caso contrrio, a cache
erra e o sistema de memria deve buscar o dado na memria principal.
679
Figura 8.7 Cache de mapeamento direto com 8 conjuntos
Exemplo 8.6 LOCALIDADE TEMPORAL COM UM CACHE DE MAPEAMENTO DIRETO

Os loops so uma fonte comum de localidades temporais e espaciais em aplicaes. Utilizando a cache de
oito entradas da Figura 8.7, mostre os contedos da cache aps a execuo do loop dummy em cdigo
assembly MIPS abaixo. Assuma que a cache est inicialmente vazia. Qual a miss rate?
addi $t0, $0, 5
loop: beq $t0, $0, done
lw $t1, 0x4($0)
lw $t2, 0xC($0)
lw $t3, 0x8($0)
addi $t0, $t0, 1
j loop
done:
680
Soluo: O programa contm um loop que se repete por cinco iteraes. Cada iterao envolve trs acessos
memria (carregamentos), resultando num total de 15 acessos memria. A primeira vez que o loop
executado, a cache est vazia e o dado deve ser buscado na memria principal, nas localizaes 04, 0 e
08 para os cache sets 1, 3 e 2, respectivamente. No entanto, nas prximas quatro vezes que o loop
executado, o dado se encontra na cache. A Figura 8.8 mostra o contedo da cache durante a ltima requisio
para o endereo de memria 04. As tags so todas 0 pois os 27 bits superiores dos endereos so 0. A miss
3
rate de 15 = 20%.
Quando dois endereos recentemente acessados mapeiam para o mesmo bloco da cache, um conflito
ocorre, e o endereo mais recentemente acessado expulsa o anterior do bloco. As caches de mapeamento
direto possuem apenas um bloco em cada conjunto, ento dois endereos que mapeiam para o mesmo
conjunto sempre causam um conflito. O Exemplo 8.7 ilustra esses conflitos.
Figura 8.8 Contedo da cache mapeado diretamente
Exemplo 8.7 CONFLITO DE BLOQUEIO DE CACHE

Qual a miss rate quando o seguinte loop executado na cache de mapeamento direto de oito palavras,
da Figura 8.7? Assuma que a cache est inicialmente vazia.
addi $t0, $0, 5
loop: beq $t0, $0, done
681
lw $t1, 0x4($0)
lw $t2, 0x24($0)
addi $t0, $t0, 1
j loop
done:
Soluo: Ambos os endereos de memria 04 e 024 mapeiam para o conjunto 1. Durante a execuo inicial
do loop, os dados no endereo 04 so carregados no conjunto 1. Ento, o dado no endereo 024
carregado no conjunto 1, expulsando o dado do endereo 04. No incio da segunda execuo do loop, o
padro se repete e a cache deve buscar novamente o dado no endereo 04, expulsando o dado do endereo
024. Os dois endereos entram em conflito, e a miss rate de 100%.
Figura 8.9 Cache associativa de conjunto de duas vias
682
Cache Associativa de Conjunto Multi-vias

Uma cache associativa de conjunto de N-vias reduz os conflitos disponibilizando blocos em cada conjunto
onde o mapeamento de dados para aquele conjunto pode ser encontrado. Cada endereo de memria
continua mapeando para um conjunto especfico, mas ele pode mapear para qualquer um dos blocos do
conjunto. Consequentemente, uma cache de mapeamento direto outro nome para uma cache associativa
de uma via. Ao tambm chamado de grau de associatividade da cache.
A Figura 8.9 mostra o hardware para uma cache associativa com = 8 palavras, = 2 vias. A cache agora
possui apenas = 4 conjuntos ao invs de 8. Portanto, apenas log 2 4 = 2 set bits ao invs de 3 so usados
para selecionar o conjunto. A tag aumenta de 27 para 28 bits. Cada conjunto contm duas vias ou graus de
associatividade. Cada via consiste num bloco de dados e os bits vlidos e tag bits. A cache l os blocos de
ambas as vias no conjunto selecionado e verifica as tags e os bits vlidos. Se ocorre acerto numa das vias, um
multiplexador seleciona o dado daquela via.
As caches associativas de conjunto geralmente possuem menores taxas de erro do que as caches de
mapeamento direto com a mesma capacidade, pois elas tm menos conflitos. No entanto, as caches
associativas de conjunto so normalmente mais lentas e ligeiramente mais caras de se construir, devido
sada multiplexada e aos comparadores adicionais. Elas tambm levantam a questo de que maneira substituir
quando ambas as vias esto ocupadas; essa questo tratada mais profundamente na Seo 8.3.3 A maioria
dos sistemas comerciais utiliza caches associativas de conjunto.
Exemplo 8.8 MISS RATE DA CACHE ASSOCIATIVA DE CONJUNTO

Repita o Exemplo 8.7 utilizando a cache associativa de conjunto de oito palavras e duas vias da Figura 8.9.
Soluo: Ambos os acessos memria, dos endereos 04 e 024, mapeiam para o conjunto 1. No entanto,
a cache tem duas vias, ento ele pode acomodar dados de ambos os endereos. Durante a primeira iterao
do loop, a cache vazia perde ambos os endereos e carrega ambas as palavras de dados nas duas vias do
conjunto 1, como mostrado na Figura 8.10. Nas prximas quatro iteraes, a cache acerta.
2
Consequentemente, a miss rate de 10 = 20%. Lembre-se que a cache de mapeamento direto, do mesmo
tamanho, do Exemplo 8.7 possua uma miss rate de 100%.
683
Figura 8.10 Contedo da cache associativa de duas vias
Cache Totalmente Associativa

Uma cache totalmente associativa contm um nico conjunto com vias, onde o nmero de blocos.
Um endereo de memria pode mapear para o bloco em qualquer uma dessas vias. Uma cache totalmente
associativa outro nome para um cache associativa de vias com um conjunto.
Figura 8.11 Cache completamente associativa de oito blocos
A Figura 8.11 mostra o array SRAM de uma cache totalmente associativa com oito blocos. Sobre a
solicitao de dados, oito tags de comparao (no mostrados) devem ser feitos, pois o dado pode estar
em qualquer bloco. Similarmente, um multiplexador 8: 1 escolhe os dados apropriados se um acerto
ocorrer. Caches totalmente associativas tendem a ter os menores erros de conflitos para uma dada
capacidade de cache, mas elas requerem mais hardware para comparaes adicionais de tags. Elas so
mais adequadas para caches relativamente pequenas, devido ao grande nmero de comparadores.
684
Tamanho de Bloco
Os exemplos anteriores eram capazes de tirar vantagem apenas da localidade temporal, pois o tamanho do
bloco era de uma palavra. Para explorar a localidade espacial, uma cache utiliza blocos maiores para manter
muitas palavras consecutivas.
A vantagem de um tamanho de bloco maior do que um que, quando um erro ocorre, e a palavra buscada
na cache, as palavras adjacentes no bloco tambm so buscadas. Portanto, acessos subsequentes so mais
propensos a acertos devido localidade espacial. No entanto, um tamanho grande de bloco significa que uma
cache de tamanho fixo ter menos blocos. Isso pode levar a mais conflitos, aumentando a miss rate. Mais ainda,
leva mais tempo buscar a cache errada aps um erro, pois mais que uma palavra de dado buscada na memria
principal. O tempo necessrio para carregar um bloco errado na cache chamado penalidade de erro. Se as
palavras adjacentes no bloco no so acessadas posteriormente, o esforo de busca-las perdido. Mesmo
assim, a maioria dos programas reais beneficiam de tamanhos de blocos maiores.
Figura 8.12 Cache mapeada diretamente com dois conjuntos e um tamanho de bloco de quatro palavras
A Figura 8.12 mostra o hardware para uma cache mapeada diretamente com = 8 palavras e com um

tamanho de bloco de = 4 palavras. A cache agora possui apenas = = 2 blocos. Uma cache de

mapeamento direto possui um bloco em cada conjunto, de modo que esta cache organizada em dois
conjuntos. Portanto, apenas log 2 2 = 1 bit utilizado para selecionar o conjunto. Um multiplexador agora
necessrio para selecionar a palavra dentro do bloco. O multiplexador controlado pelos log 2 4 = 2 bits de
685
offset de bloco do endereo. Os 27 bits mais significativos de endereo formam a tag. Apenas uma tag
necessria para todo o bloco, pois as palavras no bloco esto em endereos consecutivos.
Figura 8.13 Campos de cache para endereo 0x8000009C quando mapeado para a cache da Figura
8.12
A Figura 8.13 mostra os campos de cache para os endereos 08000009 quando mapeados para a
cache de mapeamento direto da Figura 8.12. Os bits do byte de offset so sempre 0 para acessos de
palavra. Os prximos log 2 = 2 bits de offset de bloco indicam a palavra dentro do bloco. E o prximo
bit indica o conjunto. Os 27 bits restantes so a tag. Portanto, a palavra 08000009 mapeia para o
conjunto 1, palavra 3 na cache. O princpio de se utilizar tamanhos maiores de blocos para explorar a
localizao espacial tambm aplicado a caches associativas.
Figura 8.14 Contedo da cache com um tamanho de bloco b de quatro palavras
686
Exemplo 8.9 LOCALIZAO ESPACIAL COM UMA CACHE DE MAPEAMENTO DIRETO

Repita o Exemplo 8.6 para a cache de mapeamento direto de oito palavras com um tamanho de bloco de
quatro palavras.
Soluo: A Figura 8.14 mostra o contedo da cache aps o primeiro acesso de memria. Na primeira iterao
do loop, a cache erra no acesso ao endereo de memria 04. Esse acesso carrega os dados nos endereos de
00 a 0 para o bloco da cache. Todos os acessos subsequentes (como mostrado para o endereo 0)
1
acertam na cache. Consequentemente, a miss rate de 15 = 6.67%.
Colocando Tudo Junto

As caches so organizadas em arrays bidimensionais. As linhas so chamadas conjuntos, e as colunas so
chamadas vias. Cada entrada no array consiste num bloco de dados e seus associados bits vlidos e tag. As
caches so caracterizadas por:
Capacidade
Tamanho do bloco (e nmero de blocos, = /
Nmero de blocos num conjunto
A Tabela 8.2 resume os vrios tipos de organizao de cache. Cada endereo na memria mapeia para
apenas um conjunto mas pode ser armazenado em qualquer uma das vias.
Tabela 8.2 Organizaes da cache
687
A capacidade da cache, associatividade, tamanho do conjunto e tamanho do bloco so tipicamente

potencias de 2. Isso faz com que os campos da cache (bits tags, conjuntos e offset de blocos) sejam
subconjuntos dos bits de endereo.
Aumentar a associatividade normalmente reduz a miss rate causada pelos conflitos. Mas uma maior
associatividade requer maiores comparadores. Aumentar o tamanho do bloco, , tira vantagem da
localizao espacial e reduz a miss rate. No entanto, isso diminui o nmero de conjuntos numa cache de
tamanho fixo e, portanto, pode levar a mais conflitos. Isso tambm aumenta a penalidade dos erros.
8.3.3. Qual a Informao a Substituir?
Numa cache de mapeamento direto, cada endereo mapeia para um nico bloco e conjunto. Se um
conjunto est cheio quando novos dados precisam ser carregados, o bloco naquele conjunto substitudo
com o novo dado. Em caches associativas de conjuntos e totalmente associativas, a cache deve escolher de
qual bloco retirar dados quando um conjunto est cheio. O princpio da localizao temporal sugere que a
melhor escolha retirar dados do bloco menos recentemente utilizado, pois muito pouco provvel que ele
seja utilizado em breve. Consequentemente, a maioria das caches associativas possuem uma poltica de
substituio dos menos recentemente utilizados (LRU least recently used).
Numa cache associativa de duas vias, um bit de uso, , indica qual a via dentro de um conjunto menos
recentemente utilizada. A cada vez que uma das vias utilizada, ajustado para indicar a outra via. Para
caches associativas de conjunto com mais de duas vias, localizar a via menos recentemente utilizada se torna
complicado. Para simplificar este problema, as vias so frequentemente divididas em dois grupos, e indica
qual o grupo de vias menos recentemente utilizado. Aps a substituio, o novo bloco substitui um bloco
aleatoriamente dentro do grupo menos recentemente utilizado. Tal poltica chamada pseudo-LRU e uma
prtica boa o suficiente.
Exemplo . SUBSTITUIO DA LRU

Mostre o contedo de uma cache associativa de conjunto de oito palavras e duas vias aps a execuo do
seguinte cdigo. Assuma uma substituio da LRU, um tamanho de bloco de uma palavra, e uma cache
inicialmente vazia.
688
lw $t0, 0x04($0)
lw $t1, 0x24($0)
lw $t2, 0x54($0)
Soluo: As primeiras duas instrues carregam dados dos endereos de memria 04 e 024 para o conjunto
1 da cache, mostrada na Figura 8.15 (a). = 0 indica que o dado na via 0 foi o menos recentemente utilizado.
O prximo acesso de memria, no endereo 054, tambm mapeia para o conjunto 1 e substitui o dado
menos recentemente utilizado na via 0, como mostrado na Figura 8.15 (b). O bit de uso colocado a 1 para
indicar que o dado na via 1 foi o menos recentemente utilizado.
Figura 8.15 Duas caches associativas de duas vias com substituio LRU
8.3.4. Projeto Avanado de Cache*

Os sistemas modernos utilizam mltiplos nveis de cache para diminuir o tempo de acesso memria. Esta
seo explora o desempenho de um sistema de cache com dois nveis e examina como o tamanho dos blocos,
a associatividade e a capacidade da cache afetam a miss rate. A seo tambm descreve como as caches lidam
com os armazenamentos, ou escritas, atravs do uso da poltica de Write-Trough ou Write-Back.
689
Caches de Nveis Mltiplos

As caches grandes so benficas, pois so mais propensas a armazenarem dados de interesse, e, portanto,
possuem menores miss rates. No entanto, as caches grandes tendem a ser mais lentas que as menores. Os
sistemas modernos utilizam frequentemente pelo menos dois nveis de cache, como mostrado na Figura 8.16.
A cache do primeiro nvel (1) pequena o suficiente para fornecer um tempo de acesso de um ou dois ciclos.
A cache do segundo nvel (2) tambm construdo a partir de uma SRAM mas maior, e portanto, mais
lenta, que a cache do primeiro nvel. O processador primeiramente procura pelo dado na cache 1. Se a cache
1 erra, o processador procura na cache 2. Se a cache 2 erra, o processador busca o dado na memria
principal. Muitos sistemas modernos adicionam ainda mais nveis de cache hierarquia da memria, pois
acessar a memria principal muito lento.
Figura 8.16 Hierarquia de memria com cache de dois nveis
690
Exemplo 8.11 SISTEMA COM UMA CACHE L2

Use o sistema da Figura 8.16 com tempos de acesso de 1, 10 e 100 ciclos para a cache 1, cache 2 e a
memria principal, respectivamente. Assuma que as caches 1 e 2 possuem taxas de erro de 5% e 20%,
respectivamente. Especificamente, dos 5% dos acessos que so errados na cache 1, 20% deles tambm so
errados na cache 2. Qual o tempo mdio de acesso memria (AMAT)?
Soluo: Cada acesso memria verifica a cache 1. Quando a cache 1 erra (5% do tempo), o processador
verifica a cache 2. Quando a cache 2 erra (20% do tempo), o processador busca o dado na memria
principal. Usando a Equao 8.2, calculamos o tempo mdio de acesso memria como segue: 1 +
0.05[10 + 0.2(100)] = 2.5 .
A miss rate 2 alta pois ela recebe apenas os acessos pesados memria, aqueles que foram errados
na cache 1. Se todos os acessos fossem diretamente para a cache 2, a miss rate de 2 seria em torno de
1%.
Reduzindo a Miss Rate

Os erros de cache podem ser reduzidos mudando-se a capacidade, o tamanho do bloco, e/ou a
associatividade. O primeiro passo na reduo da miss rate entender a causa dos erros. Os erros podem ser
classificados como compulsrios, capacidade e conflito. A primeira solicitao para um bloco de cache
chamada falha compulsria, pois o bloco deve ser lido da memria independentemente do projeto da cache.
As falhas de capacidade ocorrem quando a cache muito pequena para manter todos os dados
simultaneamente. As falhas de conflito so causadas quando muitos endereos mapeiam para o mesmo
conjunto e retiram blocos que ainda so necessrios.
Mudar os parmetros da cache pode afetar um ou mais tipos de falhas da cache. Por exemplo, aumentar a
capacidade da cache pode reduzir as falhas de conflito e capacidade, mas isso no afeta as falhas
compulsrias. Por outro lado, aumentar o tamanho do bloco pode reduzir as falhas compulsrias (devido
691
localizao espacial), mas pode verdadeiramente aumentar as falhas de conflito (pois mais endereos iriam
mapear para o mesmo conjunto, causando conflitos).
Os sistemas de memria so suficientemente complexos pelo que a melhor maneira de avaliar a sua
performance rodando benchmarks enquanto se variam os parmetros da cache. A Figura 8.17 representa a
taxa de falhas versus o tamanho da cache e o grau de associatividade para o benchmark SPEC2000. Esta
benchmark possui um pequeno nmero de falhas compulsrias, mostrados na regio escura perto do eixo x.
Figura 8.17 Taxas de erros versus tamanho de cache e associatividade com o benchmark SPEC2000
Adaptada com permisso de Hennessy and Patterson, Computer Architecture: A Quantitative Approach,
5th ed., Morgan Kaufmann, 2012.
692
Como esperado, quando o tamanho da cache aumenta, as falhas de capacidade diminuem. Um aumento
da associatividade, especialmente para caches pequenas, diminui o nmero de falhas de conflito mostradas
ao longo do topo da curva. Aumentar a associatividade acima de quatro ou oito vias proporciona apenas uma
pequena diminuio na taxa de falhas.
Como mencionado, a taxa de falhas tambm pode ser diminuda utilizando-se tamanhos maiores de
blocos, tirando vantagem da localizao espacial. Mas, conforme o tamanho dos blocos aumenta, o nmero
de conjuntos de tamanho fixo na cache diminui, aumentando a probabilidade de conflitos. A Figura 8.18
representa a taxa de falhas versus o tamanho do bloco (em nmero de bytes) para caches de capacidade
varivel. Para caches pequenas, como a cache de 4KB, aumentar o tamanho do bloco em cerca de 64 bytes
aumenta a taxa de falhas devido aos conflitos. Para caches grandes, aumentar o tamanho do bloco em 64
bytes no muda a taxa de falhas. No entanto, grandes blocos podem ainda aumentar o tempo de execuo
devido s maiores penalidades de falhas, o tempo requerido para buscar da memria principal o bloco de
cache em falha.
Figura 8.18 Taxas de erro versus tamanho de bloco e tamanho de cache na benchmark SPEC92 - Adaptada
com a permisso de Hennessy e Patterson, Computer Architecture: A Quantitative Approach, 5th ed,
Morgan Kaufmann, 2012
693
Poltica de Escrita
As sees anteriores tiveram seu foco nos carregamentos de memria. Armazenamentos de memria, ou
escritas, seguem um procedimento similar ao do carregamento. Mediante um armazenamento na memria,
o processador verifica a cache. Se a cache falha, o bloco de cache buscado da memria principal para a
cache, e ento a palavra apropriada no bloco de cache escrita. Se a cache acerta, a palavra simplesmente
escrita no bloco de cache.
As caches so classificadas como write-trough ou write-back. Numa cache write-trough, o dado escrito num
bloco de cache simultaneamente escrito na memria principal. Numa cache write-back, um dirty bit ()
associado a cada bloco de cache. 1 quando o bloco de cache foi escrito, e 0 caso contrrio. Os dirty blocos
de cache so escritos de volta na memria principal apenas quando so retirados da cache. Um cache write-
trough no exige dirty bits, mas usualmente requer mais escritas na memria principal do que uma cache
write -back. As caches modernas so usualmente write-back, pois o tempo de acesso memria principal
muito grande.
Exemplo 8.12 WRITE-TROUGH VERSUS WRITE-BACK

Suponha uma cache que tenha um tamanho de bloco de quatro palavras. Quantos acessos memria so
necessrios pelo seguinte cdigo, utilizando cada uma das polticas de escrita: write-through e write-back.
sw $t0, 0x0($0)
sw $t0, OxC($0)
sw $t0, 0x8($0)
sw $t0, 0x4($0)
Soluo: Todas as quatro instrues de armazenamento escrevem no mesmo bloco de cache. Com uma cache
write-through, cada instruo de armazenamento escreve uma palavra na memria principal, exigindo quatro
escritas memria principal. Uma poltica write-back requer apenas um acesso memria principal, quando
o dirty bloco da cache esvaziado.
694
8.3.5. A Evoluo das Caches MIPS*

A Tabela 8.3 traa a evoluo das organizaes de cache utilizadas pelos processadores MIPS, de 1985 a
2010. As principais tendncias so a introduo de cache de nveis mltiplos, maior capacidade de cache, e o
aumento da associatividade. Estas tendncias so conduzidas pela crescente divergncia entre frequncias
de CPU e velocidades de memrias principais, e o preo decrescente dos transstores. A crescente diferena
entre as velocidades das CPU e as memrias principais necessitam de uma menor miss rate para evitar o
bottleneck da memria principal, e o preo decrescente dos transstores permite caches com tamanhos
maiores.
Tabela 8.3 Evoluo da cache MIPS
8.4. MEMRIA VIRTUAL

A maioria dos sistemas computacionais modernos utiliza um disco rgido de armazenamento magntico ou
de estado slido como o nvel mais baixo na arquitetura de memria (vide Figura 8.4). Comparado com uma
memria ideal, grande, rpida e barata, o disco rgido grande e barato, porm, terrivelmente lento. Ele
fornece uma capacidade muito maior do que a possvel com uma memria de custo efetivo (DRAM). No
entanto, se uma frao significante do acesso memria envolve o disco rgido, seu desempenho pssimo.
Voc pode defrontar-se com isso em um PC rodando muitos programas juntos.
695
A Figura 8.19 mostra um disco rgido para armazenamento magntico, com a tampa superior removida.
Como o nome sugere, o disco rgido contm um ou mais discos rgidos ou pratos, cada um deles com uma
Um computador com cabea de escrita/leitura no fim de um brao triangular. A cabea se move para a localizao correta no
endereos de 32-bits pode disco e escreve ou l dados magneticamente com o disco abaixo dela. A cabea leva vrios milissegundos
acessar um mximo de 232 para descobrir a localizao correta no disco, o que rpido comparado perspectiva humana, mas
bytes = 4 de memria. Esta milhes de vezes mais lento do que o processador.
uma das motivaes da
O objetivo de adicionar um disco rgido hierarquia de memria o de, com um baixo custo, dar a
mudana para os iluso de uma memria muito grande, enquanto isso, continuar a fornecer a velocidade da memria mais
computadores de 64-bits, que
rpida para a maioria dos acessos. Um computador com apenas 128 MB de DRAM, por exemplo, pode
podem acessar muito mais
efetivamente fornecer 2 GB de memria utilizando o disco rgido. Essa memria maior de 2 GB chamada
memria.
memria virtual, e a memria principal, menor, de 128 MB chamada memria fsica. Utilizaremos o
termo memria fsica para nos referirmos a memria principal ao longo dessa seo.
Figura 8.19 Disco Rgido
696
Os programas podem acessar dados em qualquer lugar da memria principal, por isso, devem utilizar
endereos virtuais que especificam a localizao na memria virtual. A memria fsica mantm um
subconjunto da memria virtual mais recentemente acessada. Deste modo, a memria fsica age como uma
cache para a memria virtual. Ento, a maioria dos acessos so feitos na memria fsica velocidade da
DRAM, no entanto, o programa desfruta da capacidade de uma memria virtual maior.
Os sistemas de memria virtual utilizam diferentes terminologias para os mesmos princpios de cache
discutidos na Seo 8.3. A Tabela 8.4 resume os termos anlogos. A memria virtual dividida em pginas
virtuais, tipicamente em tamanhos de 4 KB. A memria fsica dividida da mesma forma, em pginas fsicas
de mesmo tamanho. Uma pgina virtual pode estar localizada na memria fsica (DRAM) ou no disco rgido.
Por exemplo, a Figura 8.20 mostra uma memria virtual que maior do que a memria fsica. Os retngulos
indicam as pginas. Algumas pginas virtuais esto presentes na memria fsica, e algumas esto localizadas
no disco rgido. O processo de determinao do endereo fsico a partir do endereo virtual chamado
traduo de endereos. Se o processador tenta acessar um endereo virtual que no est na memria fsica,
uma falha de pgina ocorre, e o sistema operacional carrega a pgina do disco rgido na memria fsica.
Tabela 8.4 Termos anlogos para cache e memria virtual
Para evitar falhas de pgina causadas por conflitos, qualquer pgina virtual pode ser mapeada para
qualquer pgina fsica. Em outras palavras, a memria fsica se comporta como uma cache totalmente
associativa para a memria virtual. Numa cache totalmente associativa convencional, cada bloco de cache
possui um comparador que verifica os bits de endereo mais significativos diante de uma tag, para
697
determinar se a solicitao acerta no bloco. Num sistema anlogo de memria virtual, cada pgina fsica
necessitaria de um comparador para verificar os bits de endereo mais significativos diante de uma tag, para
determinar se a pgina virtual mapeia para aquela pgina fsica.
Um sistema de memria virtual realista possui tantas pginas fsicas que fornecer um comparador para
cada uma delas seria excessivamente caro. Ao invs disso, o sistema de memria virtual utiliza uma tabela de
pginas para realizar a traduo de endereos. Uma tabela de pginas contm uma entrada para cada pgina
virtual, indicando a sua localizao na memria fsica ou a que est no disco rgido. Cada instruo de
carregamento ou armazenamento requer um acesso tabela de pginas, seguido por um acesso memria
fsica. O acesso tabela de pginas traduz o endereo virtual utilizado pelo programa num endereo fsico. O
endereo fsico , ento, utilizado para realmente ler, ou escrever, dados.
Figura 8.20 Pginas virtuais e fsicas
A tabela de pginas normalmente to grande que est localizada na memria fsica. Consequentemente,
cada carregamento ou armazenamento envolve dois acessos memria fsica: o acesso tabela de pginas,
e o acesso ao dado. Para aumentar a velocidade da traduo de endereos, um dispositivo denominado
Translation Lookaside Buffer (TLB) envia cache as entradas mais utilizadas da tabela de pginas.
O restante desta seo mostra detalhes sobre a traduo de endereos, tabelas de pgina e TLB.
698
8.4.1. Traduo de Endereos

Num sistema com memria virtual, os programas utilizam endereos virtuais de modo que eles possam
acessar uma memria maior. O computador deve traduzir estes endereos virtuais, tanto para encontrar o
endereo na memria fsica ou tomar uma falha de pgina e buscar o dado no disco rgido.
Lembre-se que a memria virtual e a memria fsica so divididas em pginas. Os bits mais significativos
dos endereos fsicos ou virtuais especificam o nmero de pgina virtual ou fsico. Os bits menos significativos
especificam a palavra dentro da pgina e so chamados offset de pgina.
A Figura 8.21 ilustra a organizao de pgina para um sistema de memria virtual com 2 GB de memria
virtual e 128 MB de memria fsica dividida em pginas de 4 KB. A MIPS acomoda endereos de 32-bits. Com
uma memria virtual de 2 = 231 bytes, apenas os 31 bits menos significativos de endereo virtual so
usados; o bit 32 sempre 0. Similarmente com uma memria fsica de 128 = 227 bytes de memria
fsica, apenas os 27 bits menos significativos de endereo fsico so utilizados; os 5 bits superiores so sempre
0.
Figura 8.21 Pginas fsicas e virtuais
699
231 227
Devido ao tamanho da pgina ser de 4 = 212 bytes, existem 212
= 219 pginas virtuais e 212
= 215
pginas fsicas. Ento, os nmeros de pginas virtuais e fsicas so 19 e 15 bits, respectivamente. A memria
fsica pode apenas manter 1/16 das pginas virtuais num dado instante. O resto das pginas virtuais
mantido no disco rgido.
A Figura 8.21 mostra o mapeamento da pgina virtual 5 para a pgina fsica 1, pgina virtual 07 para
pgina fsica 07, e assim por diante. Por exemplo, o endereo virtual 0538 (um offset de 038
dentro da pgina virtual 5) mapeia para o endereo fsico 0138 (um offset de 038 dentro da pgina
fsica 1). Os 12 bits menos significativos dos endereos fsicos e virtuais so os mesmos (038) e especificam
o offset da pgina dentro das pginas virtuais e fsicas. Apenas o nmero de pginas precisa ser traduzido para
se obter o endereo fsico a partir do endereo virtual.
A Figura 8.22 ilustra a traduo de um endereo virtual para um endereo fsico. Os 12 bits menos
significativos indicam o offset da pgina e no necessitam traduo. Os 19 bits superiores do endereo virtual
especificam o nmero de pgina virtual (Virtual Page Number - VPN) e so traduzidos para um nmero de
pgina fsica (Physical Page Number - PPN) de 15 bits. As prximas duas sees descrevem como as tabelas
de pginas e os TLB so utilizados para realizar essa traduo de endereos.
Figura 8.22 Traduo do endereo virtual para endereo fsico
700
Exemplo 8.13 TRADUO DE ENDEREO FSICO PARA ENDEREO VIRTUAL

Encontre o endereo fsico do endereo virtual 0247 utilizando o sistema de memria virtual mostrado
na Figura 8.21.
Soluo: O offset de pgina de 12 bits (047) no requer traduo. Os 19 bits restantes do endereo virtual
do o nmero de pgina virtual, ento o endereo virtual 0247 encontrado na pgina virtual 02. Na
Figura 8.21, a pgina virtual 02 mapeia para a pgina fsica 07. Ento, o endereo virtual 0247
mapeia para o endereo fsico 0747.
Figura 8.23 Tabela de pginas para a Figura 8.21
701
8.4.2. A Tabela de Pginas

O processador utiliza uma tabela de pginas para traduzir endereos virtuais em endereos fsicos. A
tabela de pginas contm uma entrada para cada pgina virtual. Essa entrada contm um nmero de
pgina fsica e um bit vlido. Se o bit vlido 1, a pgina virtual mapeia para a pgina fsica especificada na
entrada. Caso contrrio, a pgina virtual encontrada no disco rgido.
Devido tabela de pginas ser muito grande, ela armazenada na memria fsica. Vamos assumir por
agora que ela armazenada como um array contguo, como mostrado na Figura 8.23. Esta tabela de
pginas contm o mapeamento do sistema de memria da Figura 8.21. A tabela de pginas indexada com
o nmero de pgina virtual (VPN). Por exemplo, a entrada 5 especifica que a pgina virtual 5 mapeia para
a pgina fsica 1. A entrada 6 invlida ( = 0), ento a pgina virtual 6 localizada no disco rgido.
Exemplo 8.14 UTILIZANDO A TABELA DE PGINAS PARA REALIZAR TRADUO DE ENDEREOS

Encontre o endereo fsico do endereo virtual 0247 utilizando a tabela de pginas mostrada na
Figura 8.23.
Soluo: A Figura 8.24 mostra a traduo de endereo virtual para endereo fsico para o endereo virtual
0247. O offset de pgina de 12 bits no requer traduo. Os 19 bits remanescentes do endereo virtual
so o nmero de pgina virtual, 02, e do o index na tabela de pginas. A tabela de pginas mapeia a
pgina virtual 02 para a pgina fsica 07. Ento, o endereo virtual 0247 mapeia para o endereo
fsico 0747. Os 12 bits menos significativos so os mesmos em ambos os endereos, fsico e virtual.
A tabela de pginas pode ser armazenada em qualquer lugar na memria fsica, a critrio do sistema
operacional. O processador tipicamente utiliza um registrador dedicado, denominado registrador da tabela
de pginas, para armazenar o endereo base da tabela de pginas na memria fsica.
702
Para realizar um carregamento ou armazenamento, o processador deve, primeiramente, traduzir o

endereo virtual em endereo fsico, e ento acessar o dado no endereo fsico. O processador extrai o
nmero de pgina virtual do endereo virtual e o adiciona ao registrador da tabela de pginas a fim de
encontrar o endereo fsico na entrada da tabela de pginas. O processador ento l essa entrada da tabela
de pginas na memria fsica para obter o nmero de pgina fsico com o offset de pgina, para criar o
endereo fsico. Finalmente, ele l ou escreve o dado no endereo fsico. Devido tabela de pginas ser
armazenada na memria fsica, cada carregamento ou armazenamento envolve dois acessos fsicos
memria.
Figura 8.24 Traduo de endereo utilizando a tabela de pginas
703
8.4.3. O TLB (Translation Lookaside Buffer)

A memria virtual teria um srio impacto no desempenho caso fosse necessria uma leitura da tabela de
pgina em todos os carregamentos ou armazenamentos, dobrando o atraso dos carregamentos e
armazenamentos. Felizmente, o acesso tabela de pginas possui uma grande localizao temporal. A
localizao temporal e espacial dos acessos aos dados e o grande tamanho da pgina significam que muitos
carregamentos ou armazenamentos consecutivos so, provavelmente, referncias mesma pgina. Portanto,
se o processador lembra a ltima entrada da tabela de pginas que foi lida, ele provavelmente pode reutilizar
esta traduo, sem realizar a releitura da tabela de pginas. Em geral, o processador pode manter as ltimas
entradas da tabela de vrias pginas numa pequena cache denominada translation lookaside buffer (TLB). O
processador olha de lado para encontrar a traduo no TLB antes de ter que acessar a tabela de pginas na
memria fsica. Em programas reais, a grande maioria dos acessos acertam no TLB, evitando o consumo de
tempo da tabela de pginas lendo na memria fsica.
Um TLB organizado como uma cache totalmente associativa e tipicamente suporta de 16 a 512 entradas.
Cada entrada do TLB mantm uma pgina virtual e seu correspondente nmero de pgina fsico. Se o TLB
acerta, ele retorna o correspondente nmero de pgina. Caso contrrio, o processador deve ler a tabela de
pginas na memria fsica. O TLB projetado para ser pequeno o suficiente para que possa ser acessado em
menos de um ciclo. Mesmo assim, o TLB tipicamente possui uma hit rate superior a 99%. O TLB diminui o
nmero de acessos requeridos memria de dois para um, para a maioria das instrues de carregamento e
armazenamento.
Exemplo 8.15 UTILIZANDO O TLB PARA REALIZAR TRADUO DE ENDEREO

Considere o sistema de memria virtual da Figura 8.21. Utilize um TLB de duas entradas ou explique por
que necessrio o acesso tabela de pginas para traduzir os endereos virtuais 0247 e 050 para
endereos fsicos. Suponha que o TLB atualmente suporta tradues vlidas das pginas virtuais 02 e
07.
704
Soluo: A Figura 8.25 mostra o TLB de duas entradas com a solicitao para o endereo virtual 0247.
O TLB recebe o nmero de pgina virtual de cada entrada. A entrada 0 coincide e vlida, ento a solicitao
acerta. O endereo fsico traduzido o nmero fsico de pgina da entrada coincidente, 07,
concatenado com o offset da pgina do endereo virtual. Como sempre, o offset da pgina no requer
traduo.
A solicitao para o endereo virtual 050 falha no TLB. Ento, a solicitao encaminhada para a
tabela de pginas para a traduo.
Figura 8.25 Traduo de endereos utilizando um TLB de duas entradas
705
8.4.4. Proteo de Memria

At agora, esta seo teve o seu foco no uso da memria virtual para fornecer uma memria grande,
rpida e barata. Uma razo igualmente importante para o uso da memria virtual fornecer proteo
entre programas rodando simultaneamente.
Como o leitor provavelmente deve saber, os computadores modernos tipicamente rodam muitos
programas, ou processos, ao mesmo tempo. Todos esses programas esto simultaneamente presentes na
memria fsica. Num sistema computacional bem projetado, os programas devem ser protegidos uns dos
outros para que nenhum programa possa quebrar outro programa. Especificamente, nenhum programa
deve ter a capacidade de acessar a memria de outro programa, sem permisso. Isso chamado de
proteo de memria.
Os sistemas de memria virtual fornecem proteo de memria dando, para cada programa, o seu
prprio espao de endereo virtual. Cada programa pode utilizar tanta memria quando quiser em seu
espao de endereo virtual, mas apenas uma poro do espao de endereo virtual est na memria fsica
num dado instante de tempo. Cada programa pode utilizar todo o seu espao de endereo virtual sem se
preocupar com onde outros programas esto fisicamente localizados. No entanto, um programa pode
acessar apenas aquelas pginas fsicas que esto mapeadas na sua tabela de pginas. Deste modo, um
programa no pode acidentalmente, ou maliciosamente, acessar as pginas fsicas de outro programa, pois
eles no esto mapeados em suas tabelas de pginas. Em alguns casos, mltiplos programas podem
acessar instrues comuns ou dados. O sistema operacional adiciona bits de controle para cada entrada
da tabela de pginas para determinar quais os programas, se existir algum, que podem escrever nas
pginas fsicas compartilhadas.
8.4.5. Poltica de Substituio
Os sistemas de memria virtual utilizam a poltica de substituio write-back e menos recentemente
utilizada (LRU). Uma poltica write-through, onde cada escrita na memria fsica inicia uma escrita no disco
rgido, poderia ser impraticvel. Instrues de armazenamento operariam na velocidade do disco rgido,
ao invs da velocidade do processador (milissegundos ao invs de nanossegundos). Sob a poltica write-
back, a pgina fsica escrita de volta no disco rgido apenas quando ela esvaziada da memria fsica.
Escrevendo a pgina fsica de volta no disco rgido e o recarregando com uma pgina virtual diferente
706
denominado paginao, e o disco rgido num sistema de memria virtual , algumas vezes, chamado de espao
de troca (swap space). O processador pe fora uma das pginas menos recentemente usadas quando uma falta
de pgina ocorre, ento substitui aquela pgina com a pgina virtual que faltava. Para auxiliar essas polticas de
substituio, cada entrada da tabela de pginas contm dois bits de status adicionais: um dirty bit D e um use bit
U.
O dirty bit 1 se qualquer instruo de armazenamento tiver modificado a pgina fsica desde que ela foi lida
do disco rgido. Quando uma pgina fsica posta fora, ela precisa ser escrita novamente no disco rgido apenas
se o dirty bit 1, caso contrrio, o disco rgido mantm uma cpia exata da pgina.
O use bit 1 se a pgina fsica foi acessada recentemente. Assim como num sistema de cache, a substituio
exata do LRU se tornaria impraticavelmente complicada. Ao invs disso, o sistema operacional aproxima a
substituio do LRU limpando periodicamente todos os use bits na tabela de pginas. Quando uma pgina
acessada, seu use bit colocado a 1. Na ocorrncia de uma falha de pgina, o sistema operacional encontra a
pgina com = 0 para pr fora da memria fsica. Ento, no necessrio substituir a pgina menos
recentemente utilizada, apenas uma das pginas recentemente utilizadas.
8.4.6. Tabelas de Pginas Multi-nveis*
As tabelas de pginas podem ocupar uma grande quantidade de memria fsica. Por exemplo, a tabela de
pgina das sees anteriores para uma memria virtual de 2 com pginas de 4 precisaria de 219 entradas.
Se cada entrada tem 4 bytes, a tabela de pginas tem 219 22 = 221 = 2.
Para conservar a memria fsica, as tabelas de pgina podem ser quebradas em mltiplos (normalmente dois)
nveis. A tabela de pgina do primeiro nvel sempre mantida na memria fsica. Ela indica onde a pequena
tabela de pginas de segundo nvel est armazenada na memria virtual. As tabelas de pginas do segundo nvel
contm as tradues atuais para uma faixa de pginas virtuais. Se uma faixa particular da traduo no
ativamente usada, a correspondente tabela de pginas de segundo nvel pode ser retirada para o disco rgido,
evitando o desperdcio de memria fsica.
Numa tabela de pginas de dois nveis, o nmero virtual de pginas dividido em duas partes: o nmero da
tabela de pginas e o offset da tabela de pginas, como mostrado na Figura 8.26. O nmero da tabela de pgina
indexa a tabela de pginas de primeiro nvel, a qual deve residir na memria fsica. A entrada da tabela de pginas
de primeiro nvel d o endereo base da tabela de pginas de segundo nvel ou indica que ela deve ser buscada
707
no disco rgido quando = 0. O offset da tabela de pginas indexa a tabela de pgina de segundo nvel. Os
12 bits remanescentes do endereo virtual so o offset de pgina, como antes, para um tamanho de pgina
de 212 = 4.
Figura 8.26 Tabelas de pginas hierrquicas
Na Figura 8.26 o nmero de pgina virtual de 19 bits quebrado em 9 e 10 bits, para indicar o nmero
da tabela de pgina e o offset da tabela de pgina, respectivamente. Ento, a tabela de pgina de primeiro
nvel tem 210 = 1 entradas. Se cada uma das entradas das tabelas de pgina de primeiro e segundo nveis
possuem 32 bits (4bytes) e apenas duas tabelas de pgina esto presentes, de uma vez, na memria, a
tabela de pginas hierrquica utiliza apenas (5124 ) + 2 (1 4 ) = 10 de memria
fsica. A tabela de pgina de dois nveis requer uma frao da memria fsica necessria para armazenar
toda a tabela de pgina (2MB). A desvantagem de uma tabela de pginas de dois nveis a de que ela
adiciona ainda mais um acesso memria, para a traduo quando h falha no TLB.
708
Exemplo 8.16 UTILIZANDO UMA TABELA DE PGINA MULTI-NVEL PARA TRADUO DE ENDEREO Os Sistemas Embarcados so
computadores de propsitos
A Figura 8.27 mostra o contedo possvel de uma tabela de pginas de dois nveis da Figura 8.26. O
especiais que controlam algum
contedo de apenas uma tabela de pginas de segundo nvel mostrado. Utilizando essa tabela de pginas dispositivo fsico. Eles
de dois nveis, descreva o que acontece com um acesso ao endereo virtual 00030. tipicamente consistem de um
Soluo: Como sempre, apenas o nmero virtual de pgina requer traduo. Os nove bits mais significativos microcontrolador ou DSP,
conectados a um ou mais
do endereo virtual, 00, do o nmero da tabela de pgina, o index da tabela de pginas de primeiro nvel.
dispositivos de I/O. Por exemplo,
A tabela de pgina de primeiro nvel, na entrada 00, indica que a tabela de pgina de segundo nvel reside
um forno micro-ondas pode ter
na memria ( = 1), e seu endereo fsico 02375000. um microcontrolador para ler os
Os prximos dez bits do endereo virtual, 03, so o offset da tabela de pginas, os quais do o index botes, configurar o relgio, e
para a tabela de pginas do segundo nvel. A entrada 0 est abaixo na tabela de pgina de segundo nvel, e ligar o magnetron nos tempos
apropriados. Eles contrastam
a entrada 03 est acima. A entrada 03 na tabela de pgina de segundo nvel indica que a pgina
com sistemas embarcados com
virtual reside na memria fsica ( = 1) e que o nmero fsico de pgina 0231. O nmero fsico de
computadores de propsito
pgina est concatenado com o offset de pgina para formar o endereo fsico, 02310. geral, como PC, que rodam
mltiplos programas, e
tipicamente interagem mais com
os usurios do que com um
dispositivo fsico. Sistemas como
smartphones esto sobre a linha
entre sistemas embarcados e
computadores de propsito
geral.
709
Figura 8.27 Traduo de endereos utilizando uma tabela de pginas de dois nveis
8.5. INTRODUO AO I/O

Os Sistemas de Entrada/Sada (Input/Output I/O) so utilizados para conectar um computador com
dispositivos externos chamados perifricos. Num computador pessoal, os dispositivos tipicamente incluem
teclados, monitores, impressoras e redes wireless. Em sistemas embarcados, dispositivos podem incluir o
elemento de aquecimento de uma torradeira, um sintetizador de voz de uma boneca, a injeo de
710
combustvel de um motor, o motor de posicionamento do painel solar de um satlite, e assim por diante.
Um processador acessa um dispositivo I/O utilizando os barramentos de dados e de endereos, da mesma
forma que ele acessa a memria. Algumas arquiteturas,
notavelmente a x86, utiliza
instrues especializadas ao invs
de uma I/O mapeada em
memria para se comunicar com
outros dispositivos I/O. Essas
instrues so da seguinte forma,
onde device1 e device2 so
a nica ID para o dispositivo
perifrico:
lwio $t0, device1
swio $t0, device2
Esse tipo de comunicao entre

dispositivos I/O chamada I/O
programada.
Figura 8.28 Hardware suporte para I/O mapeada em memria
Uma poro do espao de endereos dedicada aos dispositivos I/O, ao invs de memria. Por exemplo,
suponha que os endereos na faixa de 00000 a 0 so utilizados para I/O. Lembre-se, da
Seo 6.6.1, que esses endereos esto numa poro reservada do mapa de memria. A cada dispositivo I/O
atribudo um ou mais endereos de memria nessa faixa. Um armazenamento para o endereo
especificado envia dados para o dispositivo. Um carregamento recebe dados do dispositivo. Este mtodo de
comunicao com dispositivos I/O chamado I/O mapeada em memria.
Num sistema com I/O mapeada na memria, um carregamento ou armazenamento pode acessar a
memria ou um dispositivo I/O. Figura 8.28 mostra o hardware necessrio para manter dois dispositivos I/O
711
mapeados na memria. Um decodificador de endereos determina qual o dispositivo que comunica com o
processador. Ele utiliza os sinais Adress e MemWrite para gerar os sinais de controle para o restante
hardware. O multiplexador ReadData seleciona entre a memria e os vrios dispositivos I/O. Os registradores
ativados para escrita mantm os valores escritos nos dispositivos I/O.
Exemplo 8.17 COMUNICAO COM DISPOSITIVOS I/O

Suponha que ao dispositivo I/O 1 da Figura 8.28 atribudo o endereo de memria 04.
Mostre o cdigo assembly MIPS para a escrita do valor 7 no Dipositivo I/O 1 e para ler o valor de sada do
Dipositivo I/O 1.
Soluo: O seguinte cdigo assembly MIPS escreve o valor 7 no dispositivo de I/O 1.
addi $t0, $0, 7
sw $t0, 0xFFF4($0) # FFF4 is sign-extended to 0xFFFFFFF4
o decodificador de endereos declara WE1, pois o endereo 04 e MemWrite TRUE. O valor
no barramento WriteData, 7, escrito no registrador conectado aos pinos de entrada do dispositivo I/O 1.
Para ler do do dispositivo I/O 1, o processador realiza o seguinte cdigo assembly MIPS:
lw $t1, 0xFFF4($0)
O decodificador de endereos coloca 1:0 para 012, pois ele detecta o endereo 04 e
MemWrite FALSE. A sada do Dispositivo I/O 1 passa atravs do multiplexador para o barramento ReadData
e carregada em $t1 no processador.
Um software que comunica com um dispositivo I/O chamado driver de dispositivo. O leitor
provavelmente j fez o download ou instalou drivers de dispositivos para a sua impressora ou outro
dispositivo I/O. Escrever um driver de dispositivo requer conhecimento detalhado sobre o hardware do
dispositivo I/O. Outros programas chamam funes no driver do dispositivo para acessar o dispositivo sem
ter que entender seu hardware de baixo nvel.
712
Os endereos associados aos dispositivos I/O so frequentemente chamados registradores I/O, pois eles
podem corresponder-se com registradores fsicos no dispositivo I/O, como aquele mostrado na Figura 8.28.
As prximas sees deste Captulo fornecem exemplos concretos de dispositivos I/O. A Seo 8.6
examina o I/O no contexto dos sistemas embarcados, mostrando como utilizar um microcontrolador
baseado em MIPS para controlar muitos dispositivos fsicos. A Seo 8.7 avalia a maioria dos sistemas de
I/O utilizados em PC.
8.6. SISTEMAS DE I/O EMBARCADOS

OS sistemas embarcados utilizam um processador para controlar interaes com o ambiente fsico. Eles
so construdos em torno de unidades microcontroladoras (MCUs) que combinam um microcprocessador
com um conjunto de perifricos easy-to-use, tais como os pinos de I/O analgicos e digitais de propsito
geral, portas seriais, temporizadores, etc. Os microcontroladores so geralmente baratos, e so projetados
para minimizar o custo e o tamanho do sistema, atravs da integrao da maioria dos componentes
necessrios, num nico chip. A maioria so menores e mais leves do que uma moeda de dez centavos,
consomem miliwatts de potncia, e custam de centavos a muitos dlares. Os microcontroladores de 8-bits
so os mais pequenos e baratos, enquanto os microcontroladores de 32-bits oferecem mais memria e
desempenho superior.
Por uma questo de concretude, esta seo ir ilustrar os sistemas I/O embarcados no contexto de um
microcontrolador comercial. Especificamente, ns iremos focar no 32675512, um membro da
serie 32 da Microchip, baseada em microprocessadores MIPS de 32-bits. A famlia 32 tambm
possui uma grande variedade de perifricos on-chip e memria, de modo que o sistema completo pode ser
construdo com poucos componentes externos. Selecionamos essa famlia pois barata, possui um
ambiente de desenvolvimento fcil de se utilizar, baseada na arquitetura MIPS estudada nesse livro, e
porque a Microchip uma das lderes de vendas em microcontroladores, que vende mais de um bilho de
713
chips ao ano. Os sistemas de I/O microcontrolados so bem similares entre um ou outro fabricante, logo os
princpios ilustrados para o 32 podem facilmente ser adaptados para outros microcontroladores.
O restante desta seo ir ilustrar como os microcontroladores realizam o I/O digitais, analgicas e seriais,
de propsito geral. Os temporizadores (timers) tambm so comumente utilizados para gerar ou medir
intervalos de tempo precisos. A seo concluda com outros perifricos interessantes, como displays, motores
e links wireless.
8.6.1. O Microcontrolador PIC32MX675F512H
Figura 8.29 Mapa de memria do PIC32 (2012 Microchip Technology; Reimpresso com permisso)
714
A Figura 8.29 mostra um diagrama de blocos para um microcontrolador da srie 32. No corao do Aproximadamente $16 bilhes
sistema, h um processador MIPS de 32-bits. O processador conectado, via barramento de 32-bits, em microcontroladores foram
memria Flash contendo o programa, e SRAM contendo os dados. O 32675512 possui 512 vendidos em 2011, e o mercado
de FLASH e 64 de RAM; outros modelos com 16 a 512 de FLASH e 4 a 128 de RAM esto continua a crescer cerca de 10%
disponveis em vrios preos. Perifricos de alto desempenho, como USB e Ethernet, tambm se comunicam ao ano. Os microcontroladores
diretamente com a RAM atravs de um barramento matricial. Os perifricos de menor desempenho, vm-se tornando onipresentes e
incluindo portas seriais, temporizadores e conversores A/D, compartilham um barramento de perifricos quase invisveis, com um nmero
de cerca de 150 em cada casa, e
separado. O chip tambm contm circuitos de gerao de temporizao para produzir os clocks, e circuitos
50 em cada automvel em 2010.
sensitivos de tenso, para detectar quando o chip alimentado ou quando est prestes a perder a potncia.
O clssico 8051 um
microcontrolador de 8-bits
originalmente desenvolvido pela
Intel em 1980, e agora vendido
por um grupo de fabricantes. As
series PIC16 e PIC18, da
Microchip, so lderes no
mercado de 8-bits. A srie Atmel
AVR tem-se popularizando entre
os amadores como sendo o
crebro da plataforma Arduino.
Entre os microcontroladores de
32-bits, a Renesas lidera todo o
mercado, enquanto a ARM uma
jogadora principal em sistemas
mveis, incluindo o iPhone.
Freescale, Samsung, Texas
Instruments e Infineon so outros
dos principais fabricantes de
microcontroladores.
Figura 8.30 Diagrama de blocos do PI32MX675512H (2012 Microchip Technology; Reimpresso com
permisso)
715
Figura 8.31 Pinout do PIC32MX6xxFxxH. Os pinos

pretos so tolerantes a 5V (2012 Microchip
Technology; Reimpresso com permisso)
716
A Figura 8.30 mostra o mapa virtual de memria do microcontrolador. Todos os endereos utilizados pelo
programador so virtuais. A arquitetura MIPS oferece um espao de endereos de 32-bits para acessar
232 bytes = 4 GB de memria, mas apenas uma pequena frao dessa memria verdadeiramente
implementada no chip. As sees relevantes, na faixa 00000000 002, incluem a RAM, a Flash,
e os registradores de funes especiais, utilizados para fazer a comunicao com perifricos. Note que existe
um adicional de 12 de Boot Flash, que tipicamente realiza alguma inicializao, e salta de seguida para o
programa principal na memria Flash. No reset, o contador de programa inicializado para o comeo do Boot
Flash, no endereo 000000.
Figura 8.32 PIC32 em
A Figura 8.31 mostra pinout do microcontrolador. Os pinos incluem alimentao, terra, clock, reset, e encapsulamento TQFP de 64
muitos pinos de I/O que podem ser utilizados para propsitos gerais e/ou para perifricos de propsitos pinos
especiais. A Figura 8.32 mostra uma fotografia de um microcontrolador num encapsulamento TQFP (Twin
Quad Flat Pack) de 64 pinos, com pinos ao redor dos quatro lados, espaados de intervalos de 20 mils (0.02
polegadas). O microcontrolador tambm est disponvel em um encapsulamento de 100 pinos, com mais
pinos de I/O; esta verso possui um nmero de componente terminando com um L ao invs de um H.
A Figura 8.33 mostra o microcontrolador conectado numa configurao operacional mnima, com uma
fonte de alimentao, um clock externo, uma chave de reset, e um jack para um cabo de programao. O
32 e os circuitos externos so montados numa placa de circuito impresso. Esta placa pode ser um produto
real (um controlador de torradeira, por exemplo), ou uma placa de desenvolvimento, facilitando o acesso ao
chip durante os testes.
O regulador 1117 3.3 aceita uma entrada de 4.5 12 (por exemplo, de um transformador,
bateria ou circuito de alimentao externo) e a diminui para uma tenso contnua de 3.3 , requerida nos
pinos de alimentao. O 32 possui mltiplos pinos VDD e GND, para reduzir o rudo causado pela fonte de
alimentao, oferecendo um caminho de baixa impedncia. Uma variedade de capacitores de by-pass fornece
uma reserva de carga, para manter a fonte de alimentao estvel num evento de mudanas abruptas na
demanda de corrente. Um capacitor de by-pass tambm conecta o pino VCORE, que serve como um regulador
de tenso interno de 1.8 . O 32 tipicamente drena 1 2 / de corrente da fonte de alimentao.
Por exemplo, a 80 , a dissipao mxima de potncia = = (3.3)(120) = 0.396 . O
717
encapsulamento TQFP de 64 pinos possui uma resistncia trmica de 47/, ento o chip pode aquecer
cerca de 19 se operado sem um dissipador de calor ou cooler.
O clock do barramento perifrico
pode ser configurado para operar
mesma velocidade que o clock do
sistema principal, ou a metade, ou a
um quarto, ou oitavo da velocidade.
Os primeiros microcontroladores
PIC32 eram limitados a metade da
velocidade, no mximo, pois alguns
perifricos eram muito lentos, mas a
maioria dos produtos atuais podem
trabalhar em plena velocidade. Se o
leitor modificar a velocidade do
PBCLK, ir precisar ajustar partes do
cdigo de amostra nessa seo, tal
como o nmero de ticks de PBCLK
para medir uma certa quantidade de
tempo.
Figura 8.33 Esquemtico bsico de operao do PIC32
Um oscilador externo trabalhando a mais de 50 pode ser conectado ao pino de clock. Nesse circuito
de exemplo, o oscilador est trabalhando a 40.000 . Alternativamente, o microcontrolador pode ser
programado para utilizar um oscilador interno trabalhando a 8.00 2%. Isso muito menos preciso
em frequncia, mas pode ser suficiente. O clock do barramento de perifricos, PBCLK, para os dispositivos
I/O (portas seriais, conversores A/D, timers) tipicamente rodam a uma frao (metade) da velocidade do
718
sistema de clock principal. Esse esquema de clock pode ser determinado pelos bits de configurao no
software de desenvolvimento MPLAB, ou pela colocao das seguintes linhas de cdigo no incio do seu
programa em C.
#pragma config FPBDIV = DIV_2 // peripherals operate at half
// sysckfreq (20 MHz)
#pragma config POSCMOD = EC // configure primary oscillator in
// external clock mode
#pragma config FNOSC = PRI // select the primary oscillator
sempre conveniente fornecer um boto de reset, para que seja possvel colocar o chip em um estado Figura 8.34 Microchip ICD3
inicial de operao conhecido. O circuito de reset consiste numa chave do tipo push-button e um resistor
. O pino de reset ativo a baixo, indicando que o processador reinicia
conectado ao pino de reset,
quando o pino est em 0. Quando o boto no est pressionado, a chave est aberta e o resistor leva o pino
para 1, permitindo a operao normal. Quando o boto pressionado, a chave fecha e leva o pino de reset
para 0, forando o processador a reiniciar. O 32 tambm se reinicia automaticamente quando a
alimentao ligada.
O modo mais fcil de programar o microcontrolador com o InCircuit Debugger (ICD) 3, da Microchip. O
3, mostrado na Figura 8.34, permite ao programador comunicar-se com o 32 a partir de um , para
fazer o download do cdigo e o debug do programa. O 3 conectado por uma porta USB no PC e por um
conector modular 11 de seis pinos na placa de desenvolvimento do 32. O conector 11 o
conhecido conector utilizado em jacks de telefone. O 3 se comunica com o 32 atravs de uma interface
serial de programao In Circuit de dois fios (ICSP) com um clock e um pino de dados bidirecionais. O leitor
pode utilizar o Ambiente Integrado de Desenvolvimento (IDE Integrated Development Environment) grtis
da Microchip, o MPLAB, para escrever os seus programas em linguagem assembly ou C, simul-los, fazer o
download e test-los numa placa de desenvolvimento atravs do ICD.
Figura 8.35 LED e chaves
A maioria dos pinos do microcontrolador 32 so, por padro, pinos de I/O digitais para propsitos conectados ao porto D GPIO
gerais. Devido ao chip possuir um nmero limitado de pinos, esses mesmos pinos so compartilhados para de 12 bits
funes de I/O de propsitos especiais, tais como, portas seriais, entradas de conversores analgico-digital,
etc, que so ativados quando o correspondente perifrico ativado. responsabilidade do programador
719
utilizar cada pino para apenas um propsito a um dado intervalo de tempo. O restante da Seo 8.6 explora,
em detalhes, as funes I/O do microcontrolador.
No contexto da manipulao de
bits, ativar significa escrever 1 e As capacidades dos microcontroladores vo alm do que pode ser discutido no espao limitado desse
limpar significa escrever 0 Captulo Veja o datasheet dos fabricantes para mais detalhes. Em particular, os Family Data Sheet
325/6/7 e os 32 Family Reference Manual, da Microchip, so autorizados e
razoavelmente legveis.
8.6.2. Pinos I/O Digitais de Propsito Geral
Os pinos I/O de Propsito Geral (GPIO) so utilizados para ler ou escrever sinais digitais. Por exemplo, a
Figura 8.35 mostra oito diodos emissores de luz (LED) e quatro chaves conectadas a uma porta GPIO de 12
bits. O esquemtico indica o nome e o nmero do pino de cada um dos 12 pinos de portas. Isso diz ao
programador a funo de cada pino e ao projetista de hardware quais as conexes que devem ser feitas
fisicamente. Os LED so conectados para acenderem quando receberem um nvel 1 e apagarem quando
receberem um nvel 0. As chaves produzem 1 quando esto fechadas e 0 quando esto abertas. O
microcontrolador pode utilizar a porta tanto para mudar o estado do LED quanto para ler o estado das
chaves.
O 32 organiza grupos de GPIOs em portos que so escritos juntos. O nosso 32 denomina essas
portas: RA, RB, RC, RD, RE, RF E RG. Elas so referidas como porto A, porto B, etc. Cada porto pode ter at
16 pinos GPIO, apesar de o 32 no possuir pinos suficientes para disponibilizar muitos sinais para todos
esses portos.
Cada porta controlada por dois registradores: TRISx e PORTx, onde x uma letra, de A a G, indicando o
porto de interesse. Os registradores TRISx determinam se o pino do porto uma entrada ou uma sada,
enquanto os registradores PORTx indicam o valor lido de uma entrada ou dirigido a uma sada. Os 16 bits
menos significativos de cada registrador correspondem aos dezesseis pinos do porto GPIO. Quando um dado
bit do registrador TRISX 0, o pino uma sada, e quando 1, o pino uma entrada. prudente deixar pinos
no utilizados, como entradas (seus estados padro), de modo que eles no possam, inadvertidamente,
serem levados a valores indesejados.
720
Cada registrador mapeado na memria para uma palavra no espao de Registradores de Funes
Especiais na memria virtual (0800000 8). Por exemplo, O TRISD endereado em
088600, e PORTD est endereado em 088600. O arquivo de cabealho, ou header,
p32xxxx.h, declara esses registradores como sendo nmeros inteiros sem sinal (unsigned) de 32-bits.
Consequentemente, o programador pode acessa-los pelo nome ao invs de ter que procurar pelos endereos.
Exemplo 8.18 GPIO PARA CHAVES E LED

Escreva um programa em C para ler a quatro chaves e ligar os correspondentes quatro LED utilizando o
hardware da Figura 8.35.
Soluo: Configure o TRISD de modo que os pinos RD[7: 0] sejam sadas e RD[11: 8] sejam entradas. Ento
leia as chaves examinando os pinos RD[11: 8], e escreva os valores de volta em RD[3: 0] para ligar os LED
apropriados.
#include <p32xxxx.h>
int main(void) {
int switches;
TRISD = 0xFF00; // set RD[7:0] to output,

// RD[11:8] to input
while (1) {
switches = (PORTD >> 8) & 0xF; // Read and mask switches from
// RD[11:8]
PORTD = switches; // display on the LED
}
}
O Exemplo 8.18 escreve a entrada inteira de uma vez s. possvel tambm acessar bits individuais. Por
exemplo, o seguinte cdigo copia o valor da primeira chave para o primeiro LED:
PORTDbits.RD0 = PORTDbits.RD8;
721
Cada porto tambm possui registradores correspondentes SET e CLR que podem ser escritos com uma
mscara indicando quais bits ativas ou limpar. Por exemplo:
PORTDSET = 0b0101;
PORTDCLR = 0b1000;
Ativa o primeiro e terceiro bits de PORTD e limpa o quarto bit. Se os quatro bits inferiores de PORTD
fossem 1110, eles se tornariam 0111.
O nmero de pinos GPIO disponveis depende do tamanho do encapsulamento. A Tabela 8.5 resume quais
pinos esto disponveis em vrios encapsulamentos. Por exemplo, um TQFP de 100 pinos fornece RA[15: 14],
RA[10: 9] e RA[7: 0] para o porto A. Atente-se para o fato de que RG[3: 2] apenas para entrada. Da mesma
forma, RB[15: 0] so compartilhados como pinos de entrada analgica, e os outros pinos tambm possuem
mltiplas funes.
Os nveis lgicos so compatveis com LVCMOS. Os pinos de entrada esperam nveis lgicos de =
0,15 e = 0,8 , ou 0,5 e 2.6, assumindo = 3,3. Pinos de sada produzem de 0,4 e
de 2,4 , enquanto a corrente de sada no pode exceder uns mseros 7.
Tabela 8.5 Pinos GPIO do PI32MX5xx/6xx/7xx
722
8.6.3. I/O Serial

Se um microcontrolador precisa mandar mais bits do que o nmero de pinos livres de GPIO, ele deve
quebrar a mensagem em mltiplas transmisses menores. Em cada passo, ele pode enviar um bit ou muitos
bits. A primeira forma chamada I/O serial e a segunda chamada I/O paralela. A I/O serial popular pois
utiliza poucas conexes e rpida o suficiente para muitas aplicaes. De fato, ela to popular que
mltiplos padres para I/O serial tm sido estabelecidos, e o 32 tm hardware dedicado para
facilmente enviar dados por esses padres. Esta seo descreve os protocolos padro Serial Peripheral
Interface (SPI) e Universal Asynchronous Receiver/Transmitter (UART).
Outros padres seriais comuns incluem a Inter-Integrated Circuit (I2C), Universal Serial Bus (USB), e
Ethernet. A I2C uma interface de dois fios com um clock e um pino de dados bidirecional. utilizada de
um modo similar SPI. O USB e a Ethernet so padres mais complexos, de alta performance, e so
descritos nas Sees 8.7.1 e 8.7.4,respectivamente.
Serial Peripheral Interface (SPI)
A interface SPI um simples protocolo serial sncrono, fcil de usar e relativamente rpido. A interface
fsica consiste de trs pinos: Serial Clock (SCK), Serial Data Out (SDO) e Serial Data In (SDI). A SPI conecta
um dispositivo mestre a um dispositivo escravo, como mostrado na Figura 8.36 (a). O mestre produz o
clock. Ele inicia a comunicao iniciando uma srie de pulsos de clock em SCK. Se ele quer enviar dados ao
escravo, ele coloca o dado em SDO, comeando pelo bit mais significativo. O escravo pode
simultaneamente responder colocando um dado no SDI do mestre. A Figura 8.36 (b) mostra as formas de
onda da SPI para a transmisso de um dado de 8-bits.
723
As taxas de transmisso do a Tabela 8.6 Campos do registrador SPIxCON

taxa de sinalizao, medida em
smbolos por segundo, enquanto
a taxa de bits d a taxa de dados,
medida em bits por segundo. A
sinalizao discutida nesse texto
a sinalizao de 2 nveis, onde
cada smbolo representa um bit.
No entanto, a sinalizao multi-
nvel pode enviar mltiplos bits
por smbolo, por exemplo, a
sinalizao de 4 nveis envia dois
bits por smbolo. Nesse caso, a
taxa de bits o dobro da taxa de
transmisso. Num sistema
simples onde cada smbolo um
bit e cada smbolo representa
dados, a taxa de dados igual
taxa de bits. Algumas convenes
de sinalizao requerem bits
sobrepostos junto aos dados. Por
exemplo, um sistema de
sinalizao de dois nveis que usa
dois bits sobrepostos para cada 8
bits de dados com uma taxa de
9600 baud possui uma taxa de
bits de (9600
smbolos/segundo)x(8 bits/10
smbolos)=7680 bits/segundo.
724
Figura 8.36 Conexo SPI e formas de onda do mestre
O 32 possui at quatro portas SPI, nomeadas, sem surpresa, 1 4. Cada uma pode operar
como mestre ou como escravo. Esta seo descreve o modo mestre de operao, mas o modo escravo
similar. Para utilizar uma porta SPI, o programa PIC deve, primeiramente, configurar o porto. Ele pode,
ento, escrever o dado num registrador. O dado transmitido serialmente para o escravo. O dado coletado
do escravo coletado em outro registrador. Quando a transmisso completada, o PIC32 pode ler o dado
recebido.
Cada porta SPI associada a quatro registradores de 32 bits: SPIxCON, SPIxSTAT, SPIxBRG e SPIxBUF. Por
exemplo, SPI1CON o registrador de controle para o porto 1 da SPI. Ele utilizado para ativar a SPI e ativar
atributos, como o nmero de bits a serem transferidos e a polaridade do clock. A Tabela 8.6 lista os nomes
e funes de todos os bits dos registradores CON. Todos tem um valor padro 0 de reset. A maioria das
funes, como framing, buffering avanado, seleo de sinais escravos, e interrupes, no so utilizadas
nessa seo, mas podem ser encontradas no datasheet. STAT o registrador de dados indicando, por
exemplo, se o registrador receptor est cheio. Novamente, os detalhes desse registrador tambm esto
totalmente descritos no datasheet do 32.
725
A API sempre envia dados em O clock serial pode ser configurado para pulsar com a metade da taxa de clock perifrico ou menos. A
ambas as direes em cada SPI no possui limite terico de taxa de dados, e pode facilmente operar a dezenas de MHz numa placa de
transferncia. Se o sistema circuito impresso, embora possa apresentar problemas de rudo acima de 1 MHz quando so utilizados fios
necessita apenas enviar dados numa breadboard. BRG o registrador de taxa de transmisso que ativa a velocidade de SCK relativa ao
para o escravo, o bit recebido do clock perifrico de acordo com a frmula:
escravo pode ser ignorado. Se o

mestre deseja apenas receber = (8.3)
2(+1)
dados do escravo, ele deve
continuar a disparar a BUF o buffer de dados. Dados escritos em BUF so transferidos atravs do porto SPI no pino SDO, e o
comunicao SPI, enviando bytes dado recebido do pino SDI pode ser encontrado lendo-se BUF aps a transferncia ser completada.
arbitrrios que o escravo ir
ignorar. Ele pode ento ler os Para preparar a SPI no modo mestre, primeiro leve-a para OFF atravs do clear no bit 15 no registrador
dados recebidos do escravo. COM (o bit ON) para 0. Zere tudo que possa estar no buffer receptor pela leitura do registrador BUF.
Determine a taxa de transmisso desejada escrevendo no registrador BRG. Por exemplo, se o clock
20
perifrico 20 MHz e a taxa de transmisso desejada de 1,25 MHz, sete BRG para [21.25] 1 = 7. Ponha
a SPI em modo master colocando o bit 5 do registrador CON (MSTEN) a 1. Ative o bit 8 do registrador CON
(CKE) de modo que SDO esteja centrado na borda de subida do clock. Finalmente, leve a SPI para ON
ativando o bit ON no registrador CON.
Para enviar dados para o escravo, escreva o dado no registrador BUF. O dado ser transmitido
serialmente, e o escravo ir, simultaneamente, enviar o dado de volta para o mestre. Espere at que o bit
11 do registrador STAT (o bit SPIBUSY) v para 0, indicando que o SPI completou sua operao. Ento, o
dado recebido do escravo poder ser lido de BUF.
O porto SPI no 32 altamente configurvel, de modo que ele possa conversar com uma grande
variedade de dispositivos seriais. Infelizmente, isso leva possibilidade de configurao incorreta do porto
e da obteno de transmisses adulteradas de dados. Os tempos relativo entre o clock e os sinais de dados
so configurados com trs bits do registrador CON, chamados CKP, CKE e SMP. Por padro, esses bits so
0, mas a temporizao na Figura 8.36 (b) utiliza CKE = 1. O mestre modifica SDO na borda de subida do SCK,
para que o escravo possa amostrar o valor na borda de subida utilizando um flip-flop de disparo pela borda.
726
O mestre espera SDI como sendo estvel perto da borda de subida de SCK, de modo que o escravo possa
modifica-lo na borda de descida, como mostrado no diagrama de temporizao. Os bits MODE32 e MODE16
do registrador CON especificam se uma palavra de 16- ou 32-bits deve ser enviada; eles tm, por padro,
valor 0, indicando uma transferncia de 8 bits.
Exemplo 8.19 ENVIANDO E RECEBENDO DADOS ATRAVS DA SPI

Projete um sistema de comunicao entre um PIC mestre e uma FPGA escrava atravs da SPI. Esboce um
diagrama esquemtico da interface. Escreva o cdigo em C para o microcontrolador enviar o caractere A e
recebe-lo de volta. Escreva o cdigo HDL para uma SPI escravo na FPGA. Como o escravo poderia ser
simplificado se ele apenas precisar receber o dado?
Soluo: A Figura 8.37 mostra a conexo entre os dispositivos utilizando o porto SPI 2. Os nmeros dos pinos
so obtidos dos datasheets dos componentes (Figura 8.31). Note que tanto os nmeros dos pinos quanto os
nomes dos sinais so mostrados no diagrama para indicar tanto a conectividade fsica quanto a lgica. Estes
pinos so tambm utilizados pelo porto GPIO RG[8: 6]. Quando a SPI ativada, esses bits do porto G no
podem ser utilizados pela GPIO.
O cdigo em C abaixo inicializa a SPI, e ento envia e recebe um caractere.
void initspi(void) {
char junk;
SPI2CONbits.ON = 0; // desativa a SPI para reiniciar
qualquer estado inicial previous state
junk = SPI2BUF; // l o buffer SPI para limpar o
buffer receptor
SPI2BRG = 7;
SPI2CONbits.MSTEN = 1; // ativa modo mestre
SPI2CONbits.CKE = 1; // seta temporizao clock-to-data
SPI2CONbits.ON = 1; // ativa SPI
}
char spi_send_receive(char send) {
727
SPI2BUF = send; // envia dado para escravo

while (SPI2STATbits.SPIBUSY); // espera at que a transmisso SPI
esteja completa
return SPI2BUF; // retorna dado recebido
}
int main(void) {
char received;
initspi(); // incializa porto SPI
received = spi_send_receive('A'); // envia letra A e byte receptor
// volta para escravo
}
Figura 8.37 Conexo SPI entre o PIC32 e o FPGA
O cdigo HDL para a FPGA listado abaixo e um diagrama de blocos com a temporizao mostrado na
Figura 8.38. A FPGA utiliza um registrador de deslocamento para manter os bits que so recebidos do mestre
e os bits que restam para serem enviados ao mestre. Na primeira borda de subida de sck aps o reset e a
cada 8 ciclos a partir de ento, um novo bit de d carregado no registrador de deslocamento. Em cada ciclo
subsequente, um bit deslocado para o sdi da FPGA, e um bit deslocado para fora do sdo da FPGA. A
728
sdo atrasada at borda de descida de sck de modo que ela possa ser amostrada pelo mestre na prxima
borda de subida. Aps 8 ciclos, o byte recebido pode ser encontrado em q.
Figura 8.38 Temporizao e circuitos do SPI escravo

module spi_slave(input logic sck, // do mestre
input logic sdi, // do mestre
output logic sdo, // para o mestre
input logic reset, // system reset
input logic [7:0] d, // dado a ser enviado
output logic [7:0] q); // dado recebido
729
logic [2:0] cnt;

logic qdelayed;
// contador de 3 bits quando todo o byte transmitido

always_ff @(negedge sck, posedge reset)
if (reset) cnt = 0;
else cnt = cnt + 3 b1;
// registrador de deslocamento carregvel

// carrega d no incio, desloca sdi para baixo a cada passo
always_ff @(posedge sck)
q <= (cnt == 0) ? {d[6:0], sdi} : {q[6:0], sdi};
// alinha sdo a borda de descida do clock

// carrega d no inicio
always_ff @(negedge sck)
qdelayed = q[7];
assign sdo = (cnt == 0) ? d[7] : qdelayed;
endmodule
Se o escravo necessita apenas receber dados do mestre, ele reduzido a um simples registrador de
deslocamento dado pelo seguinte cdigo HDL:
module spi_slave_receive_only(input logic sck, // do mestre
input logic sdi, // do mestre
output logic [7:0] q); // dado recebido
always_ff @(posedge sck)
q <= {q[6:0], sdi}; // registrador de deslocamento
endmodule
730
Algumas vezes necessrio modificar os bits de configurao para se comunicar com um dispositivo que
espera diferente temporizao. Quando = 1, SCK invertido. Quando = 0, o clock pulsa com
metade do ciclo anteriormente relativo ao dado. Quando = 1, o mestre amostra SDI meio ciclo
depois (e o escravo deve estar estvel nesse momento). Estes modos so mostrados na Figura 8.39. Tome
cuidado pois diferentes produtos SPI podem utilizar diferentes nomes e polaridades para essas opes.
Verifique cuidadosamente as formas de onda para os seus dispositivos. Pode tambm ser til examinar SCK,
SDO e SDI num osciloscpio caso voc esteja tendo dificuldades de comunicao.
Transmissor Receptor Universal Assncrono (Universal Asynchronous Receiver Transmitter) - UART
Uma UART uma I/O serial perifrica que comunica entre dois sistemas sem enviar um clock. Ao invs
disso, os sistemas devem concordar antecipadamente sobre qual a taxa de transmisso de dados a ser
utilizada e cada um deve, localmente, gerar seu prprio clock. Apesar desses sistemas de clock possurem
uma baixa frequncia de erros e uma relao de fase desconhecida, a UART gerencia comunicaes
assncronas confiveis. A UART utilizada em protocolos como 232 e 485. Por exemplo, portas
seriais de computadores utilizam o padro 232, introduzido em 1969 pela Associao das Indstrias
Eletrnicas. O padro, inicialmente imaginado para conectar os equipamentos terminais de dados (Data
Terminal Equipment DTE), tal como um computador principal a um qquipamento de comunicao de dados
(Data Communication Equipment DCE), como um modem. Apesar da UART ser relativamente lenta quando
comparada a SPI, os padres estiveram ao redor por tanto tempo que continuam importantes at hoje.
A Figura 8.40 (a) mostra uma ligao serial assncrono. O DTE envia dados para o DCE atravs da linha TX
e recebe dados de volta atravs da linha RX. A Figura 8.40 (b) mostra uma dessas linhas enviando um
caractere a uma taxa de transmisso de 9600 baud. A linha permanece em nvel lgico 1 quando no est
em uso. Cada caractere enviado como um bit de partida start (0), 7-8 bits de dados, um bit opcional de
paridade, e um ou mais bits de parada stop (1). A UART detecta a transio da descida do estado de
inatividade para transmisso, para bloquear a transmisso num tempo apropriado. Apesar de sete bits de
dados serem suficientes para enviar um caractere ASCII, oito bits so normalmente utilizados, pois eles
podem transmitir um byte arbitrrio de dados.
731
Um bit adicional, o bit de paridade, pode tambm ser enviado, permitindo ao sistema detectar se um bit
foi corrompido durante a transmisso. Ele pode ser configurado como par ou mpar. Paridade mpar
significa que o bit de paridade escolhido de tal modo que o conjunto total de dados e a paridade possuem
um nmero mpar de 1. Em outras palavras, o bit de paridade a operao XOR dos bits de dado. O
receptor pode verificar se um nmero mpar de 1 foi recebido, e enviar um erro escolha com se no.
Paridade par o inverso e, consequentemente, a operao XNOR dos bits de dados.
Figura 8.39 Clock e temporizao dos dados controlados por CKE, CKP e SAMPLE
732
Figura 8.40 Ligao serial assncrono
Uma escolha comum a de 8-bits de dados, sem paridade, e um bit de stop, formando um total de 10
smbolos para transmitir um caractere de 8-bits de informao. Consequentemente, taxas de sinalizao so
referidas em unidades de transmisso (baud) ao invs de bits por segundo. Por exemplo, 9600 baud indicam
9600 smbolos por segundo, ou 960 caracteres por segundo, resultando numa taxa de dados de 960 8 =
7680 bits de dados por segundo. Todos os smbolos devem ser configurados para a taxa de transmisso e
nmero de dados apropriados, paridade, e bits de stop, ou o dado ir ser corrompido. Isso um aborrecimento,
especialmente para usurios no tcnicos, a qual uma das razes para a interface USB (Universal Serial Bus)
estar substituindo a UART em sistemas de computadores pessoais.
Taxas de transmisso tpicas incluem 300, 1200, 2400, 9600, 14400, 19200, 38400, 57600, e 115200. As
taxas mais baixas eram utilizadas nas dcadas de 1970 e 1980, para modems que enviavam dados para as
linhas telefnicas como uma srie de tons. Em sistemas contemporneos, 9600 e 115200 so duas das taxas
de transmisso mais comuns. A de 9600 encontrada onde a velocidade no importa, e a de 115200 a mais
alta taxa de transmisso, embora ainda lenta quando comparada a outros modernos padres seriais de I/O.
O padro -232 define muitos sinais adicionais. Os sinais Request to Send (RTS) e Clear to Send (CTS) podem
ser utilizados para handshaking de hardware. Eles podem ser operados em qualquer um dos dois modos. No
modo de fluxo de controle, a DTE limpa RTS para 0 quando ela est pronta para aceitar dados de DCE. Da mesma
forma, a DCE limpa CTS para 0 quando est pronta para receber dados de DTE. Alguns datasheets usam uma
barra superior para indicar que elas so ativas a baixo. No cdigo simplex mais antigo, a DTE limpava RTS para
0 quando estava pronta para transmitir. A DCE respondia limpando CTS quando estivesse pronta para receber
a transmisso.
733
Alguns sistemas, especialmente aqueles conectados a uma linha telefnica, tambm utilizam Data
Na dcada de 1950 at 1970, os
primeiros hackers que se Terminal Ready(DTR), Data Carrier Detect (DCD), Data Set Ready (DSR), e Ring Indicator (RI) para indicar
autodenominam phreaks do quando o equipamento est conectado linha.
telefone aprenderam a controlar
os interruptores da companhia
telefnica assobiando tons
apropriados. Um tom de 2600 Hz
produzido por um apito de
brinquedo de uma caixa de cereal
Cap'n Crunch Figura 8.41) podea
ser explorada para obter
chamadas grtis de longa
distncia e internacionais.
Figura 8.41 Apito Capn

Crunch BosunWhistle.
Fotogragia de Evrim Sen,
Reimpresso com permisso)
O handshaking refere-se s
Figura 8.42 Cabo macho DE-9 (a) pinout, (b) conexes padro, e (c) conexes em modem null
negociaes entre os dois
sistemas; tipicamente, um O padro original recomendava um conector macio de 25 pinos, DB-25, mas os PC o simplificaram para
sistema sinaliza que est pronto um conector macho de 9 pinos, DE-9, com o pinout mostrado na Figura 8.42 (a). Os fios do cabo
para enviar ou receber dados, e o normalmente se conectam como mostrado na Figura 8.42 (b). No entanto, quando diretamente conectados
outro sistema reconhece esse a dois DTEs, um cabo null modem, mostrado na Figura 8.42 (c), pode ser necessrio para realizar a troca de
pedido.
RX e TX, e completar o handshaking. Como nota final, alguns conectores so machos e outros conectores
so fmeas. Em resumo, isso pode necessitar de uma grande caixa de cabos e uma certa quantidade de
734
suposies para conectar os dois sistemas utilizando a RS-232, novamente se explicando a mudana para a
USB. Felizmente, os sistemas embarcados utilizam uma configurao simplificada de 3 ou 5 fios, consistindo
de GND, TX, RX e, possivelmente, RTS e CTS.
A RS-232 representa um 0 eletricamente de 3 a 15 , e um 1 de 3 a 15 . Isso chamado sinalizao
bipolar. Um transceiver converte os nveis lgicos digitais da UART para os nveis positivos e negativos
esperados pela RS-232, e tambm fornece proteo contra descargas eletrostticas, para proteger a porta
serial de danos quando o usurio conecta o cabo. O 3232 um transceiver compatvel tanto com
lgica digital de 3.3 quanto 5. Ele contm uma bomba de carga que, em conjunto com capacitores
externos, gera na sada, 5, para fontes de alimentao de baixas tenses nicas.
O 32 possui seis UART nomeadas 1-6. Assim como na SPI, o programa PIC deve primeiramente
configurar o porto. Ao contrrio da SPI, ler e escrever podem ocorrer independentemente, pois qualquer
sistema pode transmitir sem ter recebido, e vice-versa. Cada UART associada com cinco registradores de
32-bits: , (status), , e . Por exemplo, 1 o
registrador de modo para 1. O registrador de modo utilizado para configurar a , e o registrador
utilizado para verificar quando o dado est disponvel. O registrador utilizado para ativar a taxa
de transmisso. O dado transmitido ou recebido escrevendo-se ou lendo-se o .
O registrador padro para dados de 8-bits, 1 bit de stop, sem paridade e sem controle de fluxo
/, ento, para a maioria das aplicaes, o programador est apenas interessado no bit 15, o bit ON,
o qual ativa a UART.
O registrador contm os bits para ativar os pinos de transmisso e recepo, e verificar se o buffer
de transmisso e recepo esto cheios. Aps ativar o bit ON da UART, o programador deve tambm ativar
os bits e (bits 10 e 12) do registrador , para ativar esses dois pinos. O bit (bit
9) indica que o buffer transmissor est cheio. O bit (bit 0) indica que o buffer de recepo possui
dados disponveis. O registrador tambm contm bits que indicam a paridade e erros de construo.
Um erro de construo ocorre se os bits de start ou de stop no so encontrados no tempo esperado.
735
O registrador de 16 bits utilizado para definir a taxa de transmisso para uma frao do clock do
barramento perifrico.

= (8.4)
16(+1)
A Tabela 8.7 lista configuraes de para taxas de transmisso comuns, assumindo um clock perifrico
de 20 MHz. s vezes impossvel atingir exatamente a taxa de transmisso desejada. No entanto, enquanto
o erro de frequncia for menor do que 5%, o erro de fase entre o transmissor e o receptor ir permanecer
pequeno numa durao de 10 bits, sendo o dado recebido apropriadamente. O sistema ir ento ser
novamente sincronizado no prximo bit de start.
Para transmitir o dado, espere at que . F esteja limpo, indicando que o buffer de transmisso
possui espao disponvel, e ento escreva o byte em . Para receber o dado, verifique .
para ver se o dado foi entregue, e ento leia o byte de .
Tabela 8.7 Configuraes BRG para um clock perifrico de 20 MHz
736
Exemplo 8.20 COMUNICAO SERIAL COM O PC

Desenvolva um circuito e um programa em C para um 32 comunicar com um PC atravs de uma
porta serial a uma taxa de transmisso de 115200 baud, com 8-bits de dados, 1 bit de stop, e sem paridade.
O PC pode estar rodando um programa de consola, como o PuTTY, para ler e escrever atravs da porta
serial. O programa deve dizer ao usurio para digitar uma string. Ele deve ento dizer ao usurio o que foi
digitado.
Soluo: A Figura 8.43 mostra um esquemtico para uma ligao serial. Devido a poucos PC ainda possurem
portas seriais, ns utilizamos um adaptador USB para RS-232 9, do site plugable.com, mostrado na
Figura 8.43, para fornecer uma conexo serial ao PC. O adaptador ligado a um conector fmea DE-9
soldado de modo a alimentar o transceiver, o qual converte as tenses de nveis bipolares RS-232 para a
tenso de 3.3 do microcontrolador 32. O microcontrolador e o PC so ambos DTE, ento os pinos RX
e TX devem ter conexo cruzada com o circuito. O handshaking RTS/CTS do 32 no utilizado, e o RTS
e CTS no conector 9 so conectados entre si, de modo que o PC no necessitar de handshaking.
Para configurar o PuTTY (disponvel em www.putty.org) para trabalhar com a ligao serial, selecione
Connection type para Serial e Speed para 115200. Selecione para a porta COM atribuda pelo
sistema operacional para o adaptador USB. No Windows, isso pode ser encontrado no Gerenciador de
Dispositivos, por exemplo, pode ser COM3. Na aba Connection Serial, selecione o fluxo de controle para
NONE ou RTS/CTS/. Na aba Terminal, selecione Local Echo para Force on, para ter os caracteres aparecendo
no terminal assim que voc os digita.
O cdigo listado abaixo. A tecla Enter no terminal do programa corresponde a um caractere de carriage
return denominado \r em C, com um cdigo ASCII de 00. Para avanar para o incio de uma nova linha
quando se imprime algo, envie ambos os comandos, \n e \r (carriage return e quebra de linha).
737
Figura 8.43 PIC32 para link serial
Figura 8.44 Adaptador Serial RS-232 para DB9 ( 2012 Plugable Technologies; reimpresso com permisso)
As funes para inicializar, ler e escrever na porta serial compem um simples driver de dispositivo. O driver
do dispositivo oferece um nvel de abstrao e modularidade entre o programador e o hardware, de modo que
o programador utilizando o driver de dispositivo no precisa entender o conjunto de registradores da UART. Isso
tambm simplifica a mudana do cdigo para outro microcontrolador; o driver de dispositivo deve ser reescrito,
mas o cdigo que o chama pode permanecer o mesmo.
A funo main demonstra a impresso na consola e a leitura da consola utilizando as funes

putstrserial e getstrserial. Ela tambm demonstra a utilizao de printf, da biblioteca stdio.h,
a qual automaticamente imprime atravs da UART2. Infelizmente, as bibliotecas do 32 no suportam,
atualmente, a funo scanf pela UART de um modo elegante, mas getstrserial suficiente.
738
#include <P32xxxx.h>
#include <stdio.h>
void inituart(void) {
U2STAbits.UTXEN = 1; // ativar pino de transmisso
U2STAbits.URXEN = 1; // ativar pino de recepo
U2BRG = 10; // setar taxa de transmisso para 115200 baud
U2MODEbits.ON = 1; // ativar UART
}
char getcharserial(void) {
while (!U2STAbits.URXDA); // esperar at dado disponvel
return U2RXREG; // retorna o caractere recebido da
// porta serial
}
void getstrserial(char *str) {
int i = 0;
do { // l uma string inteira at a deteco
str[i] = getcharserial(); // carriage return
} while (str[i++] != \r); // procura por carriage return
str[i1] = 0; // string null
}
void putcharserial(char c) {
while (U2STAbits.UTXBF); // espera at o buffer de transmisso estar vazio
U2TXREG = c; // transmite caractere atravs da porta serial
}
void putstrserial(char *str) {
int i = 0;
while (str[i] != 0) { // itera a string
739
putcharserial(str[i++]); // envia cada caractere

}
}
int main(void) {
char str[80];
inituart();
while(1) {
putstrserial("Please type something: ");
getstrserial(str);
printf("\n\rYou typed: %s\n\r", str);
}
}
Comunicar com a porta serial a partir de um programa em C um pouco aborrecedor, pois as bibliotecas
dos drivers de portas seriais no so padronizadas atravs dos sistemas operacionais. Outros ambientes de
programao, como Python, Matlab ou LabVIEW realizam comunicao serial sem esforo.
8.6.4. Temporizadores
Os sistemas embarcados comumente precisam medir tempo. Por exemplo, um forno micro-ondas precisa
de um temporizador para mostrar a hora do dia e outro para medir quanto tempo cozinhar. Ele pode ainda
utilizar outro para gerar os pulsos para o motor girar o prato, e um quarto para controlar a potncia,
ajustando-o para apenas ativar a energia do micro-ondas por uma frao de cada segundo.
O 32 possui cinco temporizadores de 16 bits na placa. Timer1 chamado timer Tipo A, que pode
aceitar uma fonte assncrona de clock externo, como um cristal de quartzo de 32 kHz. Os timers 2/3 e 4/5
so chamados timers tipo B. Eles rodam de modo sncrono fora do clock perifrico e podem ser pareados (por
exemplo, 2 com 3) para formar timers de 32 bits para medir longos perodos de tempo.
740
Cada temporizador associado com trs registradores de 16 bits: TxCON, TMRx e PRx. Por exemplo, T1CON
o registrador de controle para o Timer 1. CON o registrador de controle. TMR contm a contagem do
tempo atual. PR o registrador de perodo. Quando um temporizador atinge um perodo especificado, ele vai
de volta para 0 e ativa o bit TxIF no registrador de flag de interrupo IFS0. Um programa pode verificar esse
bit para detectar overflow. Alternativamente, ele pode gerar uma interrupo.
Por padro, cada temporizador age como um contador de 16-bits acumulando ticks de um clock perifrico
interno (20 em nosso exemplo). O bit 15 do registrador COM especifica o prescalar, como mostrado nas
Tabela 8.8 e Tabela 8.9 para os contadores tipo A e tipo B. Pr-escalando de : 1 faz o timer contar apenas
uma vez a cada ticks. Isso pode ser til para gerar longos intervalos de tempo, especialmente quando o clock
perifrico est rodando rpido. Os outros bits do registrador COM so levemente diferentes para os
contadores tipo A e tipo B. Veja o datasheet para mais detalhes.
Tabela 8.8 Prescalars para temporizadores do tipo A
741
Tabela 8.9 Prescalars para temporizadores do tipo B
Exemplo 8.21 PRODUO DE DELAY

Escreva duas funes que criam delays de um nmero especificado de microssegundos e milissegundos
utilizando o Timer1. Assuma que o clock perifrico est rodando a 20 .
Soluo: Cada microssegundo igual a 20 ciclos do clock perifrico. Empiricamente observamos com um
osciloscpio que a funo delaymicros possui um atraso de 6 para chamada de funo e a
inicializao do timer. Portanto, ns ativamos PR para 20 ( 6). Ento, a funo no ter acurcia
para intervalos de menos de 6 . A verificao no incio previne overflows do PR de 16 bits.
742
A funo delaymillis repetidamente invoca delaymicros(1000) para criar um nmero apropriado

de delays de 1.
void delaymicros(int micros) {

if (micros > 1000) { // Evita overflow do timer
delaymicros(1000);
delaymicros(micros-1000);
}
else if (micros > 6){
TMR1 = 0; // reseta timer para 0
T1CONbits.ON = 1; // liga timer
PR1 = (micros-6)*20; // 20 clocks por microssegundo.
// funo tem um atraso de ~6 us
IFS0bits.T1IF = 0; // limpa flag de overflow
while (!IFS0bits.T1IF); // espera at que a flag de
} // overflow seja setada
}
void delaymillis(int millis) {
while (millis--) delaymicros(1000); // repetidamente atrase 1 ms at
// que esteja feito
Outra caracterstica conveniente do temporizador a gated time accumulation, na qual o temporizador

apenas conta enquanto um pino externo est a alto. Isso permite ao temporizador medir a durao de um pulso
externo. Essa caracterstica ativada utilizando-se o registrador CON.
743
8.6.5. Interrupes
Os temporizadores so frequentemente utilizados em conjunto com interrupes, de modo que um
programa possa rodar o seu procedimento usual e, ento, periodicamente, lidar com uma tarefa quando o
temporizador gerar uma interrupo. A Seo 6.7.2 descreveu as interrupes MIPS do ponto de vista de
arquitetura. Esta seo explora como us-las num 32.
As requisies de interrupes ocorrem quando um evento de hardware ocorre, como um overflow de
um temporizador, um caractere sendo recebido pela UART, ou certos pinos GPIO comutando. Cada tipo de
requisio de interrupo ativa um bit especfico nos registradores de flags de Status de Interrupo (IFS).
O processador ento verifica o bit correspondente nos registradores de Controle de Ativao de Interrupo
(IEC). Se o bit est ativado, o microcontrolador deve responder com uma requisio de interrupo
invocando uma rotina de servio de interrupo (ISR). A ISR uma funo com argumentos void que lida
com a interrupo e zeram os bits do IFS antes do retorno. O sistema de interrupes do 32 suporta os
modos vetor-simples e vetores-mltiplos. No modo de vetor simples, todas as interrupes invocam o
mesmo ISR, que deve examinar o registrador CAUSE para determinar a razo da interrupo (se mltiplos
tipos de interrupo ocorrerem) e lidar com elas de acordo. No modo de vetores mltiplos, cada tipo de
interrupo chama uma ISR diferente. O bit MVEC no registrador INTCON determina o modo. Em qualquer
caso, o sistema de interrupo MIPS deve ser ativado com a instruo ei antes de aceitar qualquer
interrupo.
O 32 tambm permite que cada fonte de interrupo tenha uma prioridade e uma sub-prioridade
configurvel. A prioridade possui valores de 0 a 7, com 7 sendo a mais alta. Uma interrupo de alta
prioridade ir antecipar uma interrupo atual a ser tratada. Por exemplo, suponha que uma interrupo
UART ativada com prioridade 5 e uma interrupo do temporizador ativado com prioridade 7. Se o
programa est executando seu fluxo normal e um caractere aparece na UART, uma interrupo ir ocorrer
e o microcontrolador poder ler o dado da UART e lidar com ele. Se um temporizador sofre overflow
enquanto a ISR da UART est ativa, a ISR ir, por si s, ser interrompida, de modo que o microcontrolador
possa, imediatamente, tratar o overflow no temporizador. Quando isso estiver feito, ele retornar para
finalizar a interrupo na UART antes de retornar para o programa principal. De outro modo, se a
interrupo do temporizador tem prioridade 2, a ISR da UART poder completar primeiro, e ento a ISR do
temporizador seria invocado, e finalmente o microcontrolador retornaria para o programa principal.
744
A sub-prioridade est na faixa de 0 a 3. Se dois eventos com a mesma prioridade esto simultaneamente
pendentes, aquele com a maior subprioridade ir ser tratado primeiro. No entanto, a subprioridade no ir
causar uma nova interrupo para antecipar uma interrupo de mesma prioridade presentemente sendo
tratada. A prioridade e a sub-prioridade de cada evento configurada nos registradores IPC.
Cada fonte de interrupo possui um vetor na faixa de 0 a 63. Por exemplo, a interrupo de overflow do
Timer1 o vetor 4, a interrupo do UART2 RX o vetor 32, e a interrupo externa de INT0, disparada por
uma mudana de flanco no pino RD0 o vetor 3. Os campos dos registradores IFS, IEC e IPC correspondentes
a um nmero de vetor esto especificados no datasheet do 32.
A declarao de funo ISR marcada por duas diretivas de atributos especiais (__attribute__),
indicando o nvel de prioridade e o nmero do vetor. O compilador utiliza esses atributos para associar o ISR
com a requisio de interrupo apropriada. O Microchip MPLAB C Compiler For PIC32 MCUs Users Guide
possui mais informaes sobre a escrita de rotinas de servios de interrupo.
Exemplo 8.22 INTERRUPES PERIDICAS

Escreva um programa que pisque um LED a 1 utilizando interrupes.
Soluo: Iremos definir o Timer1 para ter overflow a cada 0.5 segundos e pulsar o LED entre ON e OFF no
tratamento de interrupo.
O cdigo abaixo demonstra o modo de operao multi-vetor, embora apenas a interrupo do Timer1
esteja ativada atualmente. A funo blinkISR possui atributos indicando que ela tem prioridade nvel 7
(IPL7) e para vector4 (o vetor de overflow do Timer1). O ISR pulsa o LED e limpa o bit da flag de interrupo
do Timer1 (T1IF) antes do retorno.
1
A funo initTimer1Interrupt configura o timer para um perodo de segundos, utilizando um
2
prescalar de 256: 1 e um contador de 39063 ticks. Ela ativa o modo multi-vetor. A prioridade e a sub-
prioridade so especificadas nos bits 4: 2 e 1: 0 do registrador IPC1, respectivamente. A flag de interrupo do
745
Timer1 (T1IF, bit 4 de IFS0) zerada, e a ativao da interrupo do Timer1 configurada para aceitar
interrupes do Timer1. Finalmente, a diretiva asm utilizada para garantir a instruo ei para ativar o
sistema de interrupo.
A funo main apenas espera em um loop while aps a inicializao da interrupo do temporizador.
No entanto, isso poderia fazer algo mais interessante, como jogar um jogo com o usurio, e a interrupo
ainda iria garantir que o LED pisca na taxa correta.
// A interrupo do timer1 Vector4, usando bit de enable IEC0<4>
// e bit the flag IFS0<4>, prioridade IPC1<4:2>, subprioridade IPC1<1:0>
void _ _attribute_ _((interrupt(IPL7))) _ _attribute_ _((vector(4)))
blinkISR(void) {
PORTDbits.RD0 = !PORTDbits.RD0; // pulsa o LED
IFS0bits.T1IF = 0; // limpa a flag de interrupcao
return;
}
void initTimer1Interrupt(void) {
T1CONbits.ON = 0; // desativa o timer
TMR1 = 0; // reseta timer para 0
T1CONbits.TCKPS = 3; // 1:256 prescale: 20 MHz / 256 = 78.125 KHz
PR1 = 39063; // pulsar a cada meio perodo(perodo de um Segundo)
INTCONbits.MVEC = 1; // ativa modo multi-vetor (usamos vector4)
IPC1 = 0x7 << 2 | 0x3; // prioridade 7, subprioridade 3
IFS0bits.T1IF = 0; // limpa a flag de interrupo do Timer1
IEC0bits.T1IE = 1; // ativa a interrupo do timer1
asm volatile("ei"); // ativa as interrupes do microcontrolador
T1CONbits.ON = 1; // liga o timer
}
746
int main(void) {
TRISD = 0; configura PORTD para alimentar os LED
PORTD = 0;
initTimer1Interrupt();
while(1); // espera, ou realiza algo til aqui
}
8.6.6. I/O Analgica
O mundo real um lugar analgico. Muitos sistemas embarcados precisam de entradas e sadas analgicas
para realizar uma interface com o mundo. Eles utilizam Conversores Analgico-Digitais (Analog to Digital
Converters ADC) para quantizar sinais analgicos em valores digitais, e Conversores Digital-Analgicos
(Digital to Analog Converters DAC) para realizar o inverso. A Figura 8.45 mostra os smbolos para esses
componentes. Tais conversores so caracterizados atravs da resoluo, faixa dinmica, taxa de amostragem
e acurcia. Por exemplo, um ADC pode ter = 12 bits de resoluo numa faixa a + de 0 a 5 ,
com uma taxa de amostragem de = 44 e acurcia de 3 bits menos significativos (lsbs). Taxas de
amostragem tambm podem ser listadas em amostras por segundo (sps), onde 1 = 1. A relao entre
a tenso de entrada analgica () e a amostra digital [] :
()
[] = 2
+
(8.5)

=

Por exemplo, uma tenso de entrada de 2,5 (metade da escala) poderia corresponder a uma sada de
1000000000002 = 80016 , com uma incerteza de at 3 lsbs.
747
Similarmente, um DAC pode ter = 16 bits de resoluo sobre uma faixa de sada em escala total de
= 2,56 . Ele produz uma sada de:
[]
() = (8.6)
2
Muitos microcontroladores possuem ADC de performance moderada embutidos. Para maior

desempenho (por exemplo, 16-bits de resoluo ou taxas de amostragem maiores do que 1 MHz),
frequentemente necessrio utilizar um ADC separado conectado ao microcontrolador. Poucos
microcontroladores possuem DAC, ento chips separados tambm podem ser utilizados. No entanto, os
micrcontroladores frequentemente simulam sadas analgicas utilizando a tcnica chamada Modulao por
Largura de Pulso (Pulse Width Modulation PWM). Esta seo descreve tais I/O analgicas no contexto do
microcontrolador 32.
Figura 8.45 Smbolos dos ADC e DAC
748
Converso A/D
O 32 possui um ADC de 10 bits com velocidade mxima de 1 milho de amostras por segundo (Msps).
O ADC pode-se conectar a qualquer uma das 16 portas analgicas atravs de um multiplexador analgico. As
entradas analgicas so chamadas 0-15, e compartilham os seus pinos com o porto I/O RB. Por padro,
+ o pino analgico , e o pino analgico GND. No nosso sistema, essas so as entradas de 3,3
Note que o ADC tem um uso
e 0, respectivamente. O programador deve inicializar o ADC, especificar qual o pino a ser amostrado, esperar confuso dos termos taxa de
o tempo suficiente para a tenso ser lida, iniciar a converso, esperar at que ela termine, e ler o resultado. amostragem e frequncia de
O ADC altamente configurvel, com a capacidade de percorrer mltiplas entradas analgicas em amostragem. O tempo de
amostragem, tambm chamado
intervalos programados e gerar interrupes aps a concluso. Esta seo simplesmente descreve como ler
tempo de aquisio, a
um nico pino de entrada analgico. Veja o PIC32 Family Reference Manual para detalhes e outras
quantidade de tempo necessria
caractersticas. para que a entrada estabilize
O ADC controlado por um grupo de registradores: 11-3, 1, 1, 1, e antes que a converso se inicie. A
10-. 11 o registrador de controle primrio. Ele possui um bit ON para ativar o ADC, um taxa de amostragem o nmero
de amostras coletadas por
bit SAMP para controlar quando a amostragem e a converso se iniciam, e um bit DONE para indicar quando
segundo.
a converso est completa. 13 possui [7: 0] bits, que controlam a velocidade da converso A/D.
1 o registrador de seleo de canal, especificando a entrada analgica a ser amostrada. 1
o registrador de configurao de pinos. Quando um bit 0, o pino correspondente age como uma entrada
analgica. Quando 1, o pino age como uma entrada digital. 10 mantm o resultado da converso
de 10 bits. Os outros registradores no so necessrios em nosso exemplo simples.
O ADC utiliza um registrador de aproximaes sucessivas que produz um bit do resultado em cada ciclo de
clock do ADC. Dois ciclos adicionais so necessrios para um total de 12 clocks/converso do ADC. O perodo
de clock do ADC, , deve ser de, pelo menos, 65 para que a operao seja correta. Ele definido como
um mltiplo do perodo do clock perifrico utilizando os bits ADCS de acordo com a relao:
= 2 ( + 1) (8.7)
Consequentemente, para clocks perifricos superiores a 30 , os bits do ADCS podem ser deixados com
seus valores padro de 0.
749
O perodo de amostragem a quantidade de tempo necessria para uma nova entrada se estabelecer
antes da converso ter incio. Enquanto a resistncia da fonte sendo amostrada for menor do que 5 , o
tempo de amostragem pode ser to pequeno quanto 132 , o que apenas um nmero pequeno de ciclos
de clock.
Exemplo 8.23 ENTRADA ANALGICA

Escreva um programa que leia o valor da entrada analgica no pino 11.
Soluo: A funo initadc inicializa o ADC e seleciona o canal especificado. Ela deixa o ADC no modo de
amostragem. A funo readadc encerra a amostragem e inicia a converso. Ela espera at que a converso
esteja concluda, ento recomea a amostragem e retorna o resultado da converso.
void initadc(int channel) {

AD1CHSbits.CH0SA = channel; // seleciona qual o canal a amostrar
AD1PCFGCLR = 1 << channel; // configure o pino desse canal como
// entrada analgica
AD1CON1bits.ON = 1; // ativa o ADC
AD1CON1bits.SAMP = 1; // inicia amostragem
AD1CON1bits.DONE = 0; // limpa flag DONE
}
int readadc(void) {
AD1CON1bits.SAMP = 0; // encerra amostragem, inicia converso
while (!AD1CON1bits.DONE); // espera at que a converso seja concluda
750
AD1CON1bits.SAMP = 1; // reinicia amostragem prepara para prxima

// converso
AD1CON1bits.DONE = 0; // limpa flag DONE
return ADC1BUF0; // retorna valor da conversoo
}
int main(void) {
int sample;
initadc(11);
sample = readadc();
}
Converso D/A
O 32 no possui DAC embutido, ento esta seo descreve a converso D/A utilizando DACs externos.
Ela tambm ilustra o interface do 32 com outros chips atravs das portas paralela e serial. A mesma
abordagem pode ser utilizada para realizar a interface entre o 32 e um ADC externo de maior resoluo
ou mais rpido.
Alguns DAC aceitam a entrada digital de N-bits numa interface paralela com N conexes, enquanto outros
a aceitam atravs de interfaces seriais, como a SPI. Alguns DAC exigem tanto tenses de alimentao positivas
quanto negativas, enquanto outros operam sob uma alimentao nica. Alguns suportam uma faixa flexvel
de tenses de alimentao, enquanto outros demandam uma tenso especfica. Os nveis lgicos de entrada
dever ser compatveis com a fonte digital. Alguns DAC produzem numa tenso de sada proporcional entrada
digital, enquanto outros produzem uma sada em corrente. Um amplificador operacional pode ser necessrio
para converter esse valor de corrente numa tenso na faixa desejada.
Nesta seo, ns usamos o DAC paralelo da Analog Devices, 558, de 8-bits, e o DAC serial da Linear
Technologies, 1257, de 12 bits. Ambos produzem uma sada em tenso, trabalham sobre uma tenso de
alimentao nica de 5 a 15 , utilizam = 2,4 , de modo que so compatveis com as sadas de 3,3 do
32, vm em encapsulamentos DIP, o que os torna fceis de conectar a uma breadboard, e so simples de
usar. O 558 produz uma sada numa escala de 0 a 2,56 , consome 75 , vem num encapsulamento de
751
16 pinos, e possui um tempo de estabilizao (settling time) de 1, permitindo uma taxa de sada de
1/. O datasheet se encontra em analog.com. O 1257 produz uma sada numa escala de 0
a 2,048 , consome menos de 2 , vem num encapsulamento de 8 pinos, e possui um tempo de
estabilizao de 6. A sua SPI opera a uma taxa mxima de 1,4 . O datasheet se encontra em
linear.com. A Texas Instruments outra empresa lder na fabricao de ADC e DAC.
Exemplo 8.24 SADAS ANALGICAS COM DAC EXTERNOS

Esboce um circuito e escreva o software para um simples gerador de sinais que produz ondas senoidais
e triangulares utilizando um 32, um 558 e um 1257.
Soluo: O circuito mostrado na Figura 8.46. O 558 conecta-se ao 32 atravs da porta paralela RD
de 8-bits. So conectados Vout Sense e Vout Select a Vout para definir uma faixa de sada em escala
completa de 2,56 . O 1257 se conecta ao 32 via 2. Ambos os ADC utilizam uma tenso de
alimentao de 5 e possuem um capacitor de desacoplamento de 0,1 para reduzir o rudo da fonte de
alimentao. Nos DAC, os sinais enable e load, ativos a baixo no chip, indicam quando converter a prxima
entrada digital. Eles devem ser mantidos em nvel alto enquanto uma nova entrada est sendo carregada.
O programa mostrado abaixo. A funo initio inicializa as portas paralelas e seriais, e configura o
temporizador com o perodo para produzir a frequncia de sada desejada. A SPI definida como modo de
16-bits a 1 , mas o 1257 apenas se preocupa com os ltimos 12-bits enviados. A funo
initwavetables pr-computa um array de valores de amostra para as funes senoidal e triangular. A
onda senoidal definida com uma escala de 12-bits, e a triangular para uma escala de 8-bits. Existem 64
pontos por perodo em cada onda. Mudar esse valor acarreta uma troca entre preciso e frequncia. A
752
funo genwaves percorre as amostras. Para cada amostra, ela desativa os sinais CE e LOAD para os DAC,
envia a nova amostra atravs das portas paralelas e seriais, reativa os DAC, e ento, espera at que o timer
indique que hora para a prxima amostra. A mnima frequncia senoidal e triangular, de 5 , definida
pelo registrador de perodo de 16-bits do Timer1, e a mxima frequncia, de 605 (38,7 definida
como o tempo par enviar cada ponto na funo genwaves, a qual a transmisso SPI o componente
principal.
Figura 8.46 Interfaces serial e paralela do DAC ao PIC32
753
#include <math.h> // exigido para o uso da funo seno
#define NUMPTS 64
int sine[NUMPTS], triangle[NUMPTS];
void initio(int freq) { // freq pode ser 5-605 Hz

TRISD = 0xFF00; // faz os 8bits inferiores sadas de
PORTD
SPI2CONbits.ON = 0; // desativa SPI para resetar estados anteriores

SPI2BRG = 9; // 1 MHz SPI clock
SPI2CONbits.MSTEN = 1; // ativar modo mestre
SPI2CONbits.CKE = 1; // definir clock-to-data timing
SPI2CONbits.MODE16 = 1; // ativar modo 16-bit
SPI2CONbits.ON = 1; // ativar SPI
TRISF = 0xFFFE; // fazer RF0 uma saida para controlar load e ce

PORTFbits.RF0 = 1; // definir RF0 = 1
PR1 = (20e6/NUMPTS)/freq - 1; // definir registrador de perodo para onda desejada
// frequncia
T1CONbits.ON = 1; // ativar Timer1
}
void initwavetables(void) {
int i;
754
for (i=0; i<NUMPTS; i++) {

sine[i] = 2047*(sin(2*3.14159*i/NUMPTS) + 1); // escala de 12 bits
if (i<NUMPTS/2) triangle[i] = i*511/NUMPTS; // escala de 8 bits
else triangle[i] = 510-i*511/NUMPTS;
}
}
void genwaves(void) {
int i;
while (1) {
for (i=0; i<NUMPTS; i++) {
IFS0bits.T1IF = 0; // limpa flag de overflow de timer
PORTFbits.RF0 = 1; // desativa load durante a mudana das entradas
SPI2BUF = sine[i]; // envia pontos atuais para DAC
PORTD = triangle[i];
while (SPI2STATbits.SPIBUSY); // espera at que a transferncia esteja completa
PORTFbits.RF0 = 0; // carrega novos pontos nos DAC
while (!IFS0bits.T1IF); // espera o tempo para enviar ao prximo ponto
}
}
}
int main(void) {
initio(500);
initwavetables();
genwaves();
}
755
Modulao por Largura de Pulso (Pulse Width Modulation PWM)

Outro modo de um sistema digital gerar sadas analgicas atravs da modulao por largura
de pulso PWM, no qual uma sada peridica pulsada ente o nvel lgico alto por parte do seu
perodo, e o nvel lgico baixo no tempo restante. O duty cycle a frao do perodo para o qual o
pulso tem nvel alto, como mostrado na Figura 8.47. O valor mdio da sada proporcional ao duty
cycle. Por exemplo, se a sada oscila entre 0 e 3,3 e tem um duty cycle de 25%, o valor mdio
ser 0,25 3,3 = 0,825 . Fazer a filtragem do sinal PWM com um filtro passa-baixo elimina as
oscilaes e deixa o sinal com o valor mdio desejado.
O 32 contm cinco mdulos de comparao de sada, 1-5, onde cada um, em conjunto
com o Timer2 ou Timer3, pode produzir sadas PWM. Cada mdulo de comparao de sada est
associado com trs registradores de 32 bits: , e . o registrador de
controle. Os bits do registrador devem ser definidos em 1102 para ativar o modo PWM,
e o bit ON deve estar ativado. Por padro, a comparao de sada utiliza o Timer2 no modo 16-bits,
mas os bits e 32 podem ser utilizados para selecionar o Timer3 e/ou o modo de 32-
bits. No modo PWM, define o duty cycle, o registrador de perodo do timer, , define o
perodo, e pode ser ignorado.
Figura 8.47 Sinal modulado em largura de pulso (PWM)
756
Exemplo 8.25 SADA ANALGICA COM PWM

Escreva uma funo que gere uma sada de tenso analgica utilizando PWM e um filtro RC externo. A funo
deve aceitar uma entrada entre 0 (sada de 0 ) e 256 (sada completa de 3,3).
Soluo: Use o mdulo 1 para produzir um sinal de 78.125 no pino 1. O filtro passa-baixo na Figura
8.48 possui uma frequncia de corte de:
1
= = 1,6
2
para eliminar as oscilaes de alta frequncia e passar o valor mdio.
O temporizador deve rodar a 20 com um perodo de 256 ticks, pois 20 /256 resulta na desejada
frequncia PWM de 78,125 . A entrada do duty cycle o nmero de ticks para o qual a sada possui nvel
alto. Se o duty cycle 0, a sada ir permanecer em nvel 0. Se 256 ou maior, a sada ir permanecer em nvel
alto.
O cdigo PWM utiliza 1 e o Timer2. O registrador de perodo definido em 255 para um perodo de 256
ticks. 1 definido como sendo o duty cycle desejado. 1 ento configurado no modo PWM, e o
temporizador e o mdulo de comparao de sada esto ligados. O programa deve avanar para outras tarefas
enquanto o mdulo de comparao da sada continua rodando. O pino 1 ir, continuamente, gerar o sinal
PWM at explicitamente ser desligado.
757
Figura 8.48 Sada analgica utilizando PWM e um filtro passa-baixo

void genpwm(int dutycycle) {

PR2 = 255; // define periodo para 255+1 tiques = 78.125 KHz
OC1RS = dutycycle; // seta duty cycle
OC1CONbits.OCM = 0b110; // seta modulo de comparacao de saida 1 para PWM mode
T2CONbits.ON = 1; // ativa timer2 em modo padro (20 MHz,
// 16-bit)
OC1CONits.ON = 1; // ativa modulo de comparacao de sada 1
}
8.6.7. Outros Perifricos do Microcontrolador

Os microcontroladores frequentemente realizam interfaces com outros perifricos externos. Esta seo
descreve uma variedade de exemplos comuns, incluindo displays de cristal lquido (LCD), monitores VGA,
ligaes Bluetooth, e controle de motores. Interfaces de comunicaes padro, incluindo USB e Ethernet,
so descritas nas Sees 8.7.1 e 8.7.4.
Displays LCD
Um caractere LCD um pequeno display de cristal lquido, capaz de mostrar uma ou mais linhas de texto.
Eles so comumente utilizados em painis frontais de aparelhos, como caixas eletrnicos, impressoras a
laser, e mquinas de fax que necessitam mostrar uma quantidade limitada de informao. Eles so fceis de
758
se interligar com um microcontrolador atravs da porta paralela, RS-232, ou interfaces SPI. A Crystalfontz
America vende uma grande variedade de caracteres LCDs, na faixa de 8 colunas por 1 linha at 40 colunas por
4 linhas, com escolhas de cor, luz de fundo, operao 3,3/5 , e visibilidade em luz do dia. Esses LCDs podem
custar $20 ou mais em pequenas quantidades, mas os preos caem abaixo de $5 quando o volume grande.
Figura 8.49 LCD de caracteres Crystalfontz CFAH2002-TMI 20x2 (2012 Crystalfontz America; Reimpresso
com permisso)
Esta seo d um exemplo de como realizar a interface de um microcontrolador 32 com um LCD de

caracteres atravs de uma interface de 8-bits paralela. A interface compatvel com o padro industrial para
controladores de LCD, 44780 , originalmente desenvolvido pela Hitachi. A Figura 8.49 mostra um LCD
paralelo Crystalfontz 2002 20 2.
A Figura 8.50 mostra o LCD conectado a um 32 atravs de uma interface paralela de 8-bits. A lgica
opera a 5 , mas compatvel com entradas de 3.3 do 32. O contraste do LCD definido por uma
segunda tenso, produzida por um potencimetro; o LCD usualmente mais legvel quando esta tenso est

na faixa de 4,2-4,8 . O LCD recebe trs sinais de controle: (1 para caracteres, 0 para instrues), /
759
(1 para leitura do display, 0 para escrita), e (se mantido em nvel alto por pelo menos 250, ativa o LCD
quando o prximo byte estiver pronto). Quando a instruo lida, o bit 7 returna a flag busy, indicando 1
quando ocupada e 0 quando o LCD est pronto para aceitar outra instruo. No entanto, certos passos de
inicializao e a instruo clear requerem um delay especificado, ao invs da verificao da flag busy).
Para inicializar o LCD, o 32 deve escrever uma sequncia de instrues para o LCD, como mostrado
abaixo:
Espera > 1500 aps ser aplicada
Escreve 030 para definir o modo de 8 bits
Espera > 4100
Escreve 030 para definir o modo de 8 bits novamente
Espera > 100
Escreve 030 para definir o modo de 8 bits novamente
Espera at a flag busy estar vazia
Escreve 03 para definir 2 linhas e fonte 5 8
Escreve 008 para desligar o display
Escreve 001 para limpar o display
Espera > 1530
Escreve 006 para definir o modo de entrada para incrementar o cursor aps cada caractere
Escreve 00 para ligar o display sem o cursor
Ento, para escrever textos no LCD, o microcontrolador pode enviar uma sequncia de caracteres ASCII.
Ele pode tambm enviar as instrues 001 para limpar o display, ou 002 para retornar para a posio
inicial no canto superior esquerdo.
760
Figura 8.50 Interface paralela LCD
Exemplo 8.26 CONTROLE DE LCD

Escreva um programa que escreva I love LCDs num display de caracteres.
Soluo: O seguinte programa escreve I love LCDs no display. Ele requer a funo delaymicros do
Exemplo 8.21.
761
typedef enum {INSTR, DATA} mode;

char lcdread(mode md) {
char c;
TRISE = 0xFFFF; // faz da PORTE[7:0] entrada

PORTCbits.RC14 = (md == DATA); // define instrues ou modo de dados
PORTCbits.RC13 = 1; // modo de leitura
PORTCbits.RC15 = 1; // pulsa enable
delaymicros(10); // espera resposta do LCD
c = PORTE & 0x00FF; // l um byte da porta E
PORTCbits.RC15 = 0; // desativa enable
}
void lcdbusywait(void)
{
char state;
do {
state = lcdread(INSTR); // instruo
} while (state & 0x80); // repete ate flag busy
estar limpor
}
char lcdwrite(char val, mode md) {

TRISE = 0xFF00; // fazer de PORTE[7:0]
saida
PORTCbits.RC14 = (md == DATA); // define instrues ou
modo de dados
PORTCbits.RC13 = 0; // modo de escrita
PORTE = val; // valor a escrever
762
PORTCbits.RC15 = 1; // pulsa enable

PORTCbits.RC15 = 0; // desativa enable
}
char lcdprintstring(char *str)
{
while(*str != 0) { // loop ate terminao null
lcdwrite(*str, DATA); // imprime esse caractere
lcdbusywait();
str++; // avana ponteiro para prximo caractere na
//string
}
}
void lcdclear(void)
{
lcdwrite(0x01, INSTR); // limpa display
delaymicros(1530); // espera execuo
void initlcd(void) {
// set LCD control pins
TRISC = 0x1FFF; // PORTC[15:13] so saidas, as outras, entradas
PORTC = 0x0000; // desativa todos os controles
// send instructions to initialize the display
delaymicros(15000);
lcdwrite(0x30, INSTR); // modo 8-bit
delaymicros(4100);
763
lcdwrite(0x30, INSTR); // modo 8-bit

delaymicros(100);
lcdwrite(0x30, INSTR); // modo 8-bit ainda!
lcdbusywait();
lcdwrite(0x3C, INSTR); // seta 2 linhas, fonte 5x8
lcdbusywait();
lcdwrite(0x08, INSTR); // desliga display
lcdbusywait();
lcdclear();
lcdwrite(0x06, INSTR); // seta modo de entrada para
incrementar cursor
lcdbusywait();
lcdwrite(0x0C, INSTR); // liga display sem cursor
lcdbusywait();
}
int main(void) {
initlcd();
lcdprintstring("I love LCDs");
}
Monitor VGA
Uma opo mais flexvel de display dirigir a informao a um monitor de computador. O padro de
monitor Video Graphics Array (VGA) foi introduzido em 1987 para os computadores /2, com uma
resoluo de 640 480 pixel em um tubo de raios catdicos (TRC), e um conector de 15 pinos transmitindo
informaes de cores com tenses analgicas. Monitores LCD modernos possuem maior resoluo, mas
permanecem compatveis com o padro VGA.
Num tubo de raios catdicos, um canho de eltrons varre a tela da esquerda para a direita, excitando
material fluorescente para mostrar uma imagem. TRC coloridos utilizam diferentes fsforos para as cores
vermelho, verde e azul, e trs feixes de eltrons. A fora de cada canho de eltrons determina a
intensidade de cada cor no pixel. Ao final de cada linha de varredura, o disparador deve ser interrompido
para um intervalo de apagamento horizontal, para retornar ao incio da prxima linha. Aps todas as linhas
764
de varredura estarem completas, o canho deve retornar novamente para um intervalo de apagamento
vertical, para retornar para o canto superior esquerdo. O processo se repete cerca de 60 a 75 vezes por
segundo para dar a iluso visual de uma imagem permanente.
Num monitor VGA de 640 480 pixel atualizado a 59,94 , o clock do pixel opera a 25,175, ento
cada pixel dura 39,72 . A tela cheia pode ser vista como 525 linhas de varredura de 800 pixels cada, mas
apenas 480 das linhas de varredura e 640 pixels por varredura verdadeiramente transmitem a imagem,
enquanto o restante preto. Uma linha de varredura inicia com uma back porch, a seo branca na borda
esquerda da tela. Ela ento contm 640 pixels, seguidos por uma front porch na borda direita da tela, e um
pulso de sincronia horizontal (hsync) para rapidamente mover o canho de volta para a borda esquerda. A
Figura 8.51 (a) mostra a temporizao de cada uma dessas pores da linha de varredura, comeando com os
pixels ativos. Toda a linha de varredura possui 31.778. Na direo vertical, a tela inicia com uma back porch
no topo, seguida por 480 linhas de varredura ativas, seguida por uma front porch na borda inferior e um pulso
de sincronia vertical (vsync) para retornar ao topo e iniciar a prxima frame. Uma nova frame recomeada
60 vezes por segundo. A Figura 8.51 (b) mostra a temporizao vertical; note que as unidades de tempo so
agora linhas de varredura ao invs de pixel clocks. Resolues maiores utilizam um pixel clock maior, de at
388 para 2048 1536 @ 85 . Por exemplo, 1024 768 @ 60 podem ser alcanados com um
pixel clock de 65 .
A temporizao horizontal envolve um front porch de 24 clocks, pulso hsync de 136 clocks, e back porch de
160 clocks. A temporizao vertical envolve uma front porch de 3 linha, vsync de 6 linhas, e back porch de 29
linhas.
A Figura 8.52 mostra o pinout para um conector fmea proveniente de uma fonte de vdeo. Informaes
dos pixels so transportadas com trs tenses analgicas para vermelho, verde e azul. Cada tenso est na
faixa de 0 a 0,7 , com valores mais positivos indicando mais brilho. As tenses devem ser 0 durante os front
e back porches. O cabo tambm fornece um link serial 2 para configurar o monitor.
O sinal de vdeo deve ser gerado em tempo real a uma alta velocidade, o que difcil para um
microcontrolador, mas fcil para um FPGA. Um simples display preto e branco pode ser produzido levando-se
todos os trs pinos de cores simultaneamente para 0 ou 0,7 utilizando um divisor de tenso conectado a
um pino de sada digital. Um monitor cores, por outro lado, utiliza um DAC de vdeo com trs conversores D/A
765
separados, para independentemente conduzir os trs pinos de cores. A Figura 8.53 mostra uma FPGA
conduzindo um monitor VGA atravs de um DAC de vdeo, triplo de 8 bits, 7125. O DAC recebe 8-bits
de R, G e B da FPGA. Ele tambm recebe o sinal SYNC_b, que conduzido em ativo baixo quando HSYNC ou
VSYNC so declarados. O DAC de vdeo produz trs sadas de corrente para conduzir as linhas analgicas
vermelha, verde e azul, as quais so, normalmente, linhas de transmisses de 75 , paralelas, terminadas
tanto no DAC de vdeo quando no monitor. O resistor define a escala da sada de corrente para alcanar
toda a faixa de cores. A taxa de clock depende da resoluo e da taxa de refresh, ela pode ser to alta quanto
330 , usando-se um DAC 7125330.
Figura 8.51 Temporizao do VGA: (a) horizontal, (b) vertical
766
Figura 8.52 Pintout do conector VGA
Figura 8.53 FPGA conduzindo cabo VGA atravs do vdeo DAC
767
Exemplo 8.27 MONITOR VGA

Escreva um cdigo HDL para mostrar texto e uma caixa verde em um monitor VGA utilizando o circuito
da Figura 8.53.
Soluo: O cdigo assume uma frequncia de clock do sistema de 40 e usa uma phase Locked Loop
(PLL) na FPGA para gerar o clock de 25,175 do VGA. A configurao PLL varia entre as FPGA. Para o
Cyclone III, as frequncias so especificadas com o megafunction wizard da Altera. Alternativamente, o
clock pode ser fornecido diretamente de um gerador de sinais.
O controlador VGA conta atravs das colunas e linhas da tela, gerando os sinais hsync e vsync nos tempos
apropriados. Ele tambm produz um sinal blank_b, que declarado como nvel baixo, para ordenar a volta
quando as coordenadas estiverem fora da regio ativa de 640 480.
O gerador de vdeo produz os valores das cores vermelho, verde e azul, baseado na atual localizao
(, ) do pixel. (0,0) representa o canto superior esquerdo. O gerador desenha um conjunto de caracteres
na tela, junto com um retngulo verde. O gerador de caracteres um caractere de 8 8 pixels, dando uma
dimenso de tela de 80 60 caracteres. Ele procura o caractere na ROM, onde codificado em binrio
com 6 colunas e 8 linhas. As outras duas colunas ficam em branco. A ordem do bit invertida pelo cdigo
em SystemVerilog pois a coluna mais esquerda no arquivo na ROM o bit mais significativo, que deve ser
escrito na posio menos significativa.
A Figura 8.54 mostra uma fotografia do monitor VGA enquanto esse programa est rodando. As linhas
de letras se alternam entre vermelho e azul. Uma caixa verde sobrepe parte da imagem.
module vga(input logic clk,
output logic vgaclk, // clock VGA 25.175 MHz
output logic hsync, vsync,
output logic sync_b, blank_b, // para monitor & DAC
output logic [7:0] r, g, b); // para video DAC
768
logic [9:0] x, y;
// Usar PLL para criar o VGA pixel clock de 25.175 MHz
// 25.175 MHz clk period = 39.772 ns
// Tela possui 800 clocks de comprimento por 525 de altura, mas apenas
640 x 480 usados para //display
// HSync = 1/(39.772 ns * 800) = 31.470 KHz
// Vsync = 31.474 KHz / 525 = 59.94 Hz (~60 Hz taxa de refresh)
pll vgapll(.inclk0(clk), .c0(vgaclk));
// gera sinais de temporizao do monitor
vgaController vgaCont(vgaclk, hsync, vsync, sync_b, blank_b, x, y);
// modulo definido pelo usurio para determinar cor do pixel
videoGen videoGen(x, y, r, g, b);
endmodule
module vgaController #(parameter HACTIVE = 10'd640,
HFP = 10'd16,
HSYN = 10'd96,
HBP = 10'd48,
HMAX = HACTIVE + HFP + HSYN + HBP,
VBP = 10'd32,
VACTIVE = 10'd480,
VFP = 10'd11,
VSYN = 10'd2,
VMAX = VACTIVE + VFP + VSYN + VBP)
(input logic vgaclk,
output logic hsync, vsync, sync_b, blank_b,
output logic [9:0] x, y);
// counters for horizontal and vertical positions
always @(posedge vgaclk) begin
x++;
if (x == HMAX) begin
x = 0;
y++;
769
if (y == VMAX) y = 0;
end
end
// computa sinais sync (ativo baixo)

assign hsync = ~(hcnt >= HACTIVE + HFP & hcnt < HACTIVE + HFP + HSYN);
assign vsync = ~(vcnt >= VACTIVE + VFP & vcnt < VACTIVE + VFP + VSYN);
assign sync_b = hsync & vsync;
// fora sadas para black quando saem da area legal

assign blank_b = (hcnt < HACTIVE) & (vcnt < VACTIVE);
endmodule
module videoGen(input logic [9:0] x, y, output logic [7:0] r, g, b);
logic pixel, inrect;
// dada a posicao y, escolher caractere para mostrar

// entao procurer o valor do pixel na ROM
// e mostrar em vermelho ou azul. Tambem desenhar retangulo verde.
chargenrom chargenromb(y[8:3]+8d65, x[2:0], y[2:0], pixel);
rectgen rectgen(x, y, 10d120, 10d150, 10d200, 10d230, inrect);
assign {r, b} = (y[3]==0) ? {{8{pixel}},8h00} : {8h00,{8{pixel}}};
assign g = inrect ? 8hFF : 8h00;
endmodule
module chargenrom(input logic [7:0] ch, input logic [2:0] xoff, yoff,
output logic pixel);
logic [5:0] charrom[2047:0]; // gerador de caractere ROM
logic [7:0] line; // uma linha lida de
770
ROM
// inicializa ROM com caracteres do arquivo texto

initial
$readmemb("charrom.txt", charrom);
// indexa ROM para encontrar linha do caractere

assign line = charrom[yoff+{ch-65, 3b000}]; // subtrai 65 pois A
// entrada 0
// ordem reversa de bits

assign pixel = line[3d7-xoff];
endmodule
module rectgen(input logic [9:0] x, y, left, top, right, bot,

output logic inrect);
assign inrect = (x >= left & x < right & y >= top & y < bot);
endmodule
charrom.txt
// A ASCII 65
011100
100010
100010
111110
100010
100010
771
100010
000000
//B ASCII 66
111100
100010
100010
111100
100010
100010
111100
000000
//C ASCII 67
011100
100010
100000
100000
100000
100010
011100
000000
...
772
Figura 8.54 Sada VGA
Comunicao Wireless Bluetooth

Existem muitos padres atualmente disponveis para comunicao wireless, incluindo Wi-fi, ZigBee e
Bluetooth. Os padres so elaborados e requerem circuitos integrados sofisticados, mas uma crescente
variedade de mdulos esconde a complexidade, e d ao usurio uma interface simples para comunicao
wireless. Um desses mdulos o BlueSMiRF, que uma interface wireless Bluetooth fcil de usar, que pode
ser utilizada ao invs de um cabo serial.
Tabela 8.10 Classes Bluetooth
773
Figura 8.55 Formas de onda FSK e GFSK
Figura 8.56 Mdulo BlueSMiRF e dongle USB
774
Figura 8.57 Link Bluetooth PIC32 para PC
O Bluetooth um padro wireless desenvolvido pela Ericsson em 1994 para comunicaes de velocidade
moderada e baixa potncia, em distncias de 5 a 100 metros, dependendo do nvel de potncia do transmissor.
Ele comumente utilizado para conectar fones de ouvido a um telefone celular, ou um teclado a um computador.
Ao contrrio dos links de comunicao infravermelha, ele no requer uma linha de direcionamento entre os
dispositivos.
O Bluetooth opera na banda no licenciada de uso industrial-cientfico-mdico (ISM) em 2,4 . Ele define
79 canais de rdio espaados de intervalos de 1 , partindo da frequncia de 2402 . Ele salta entre esses
canais em um padro pseudo-aleatrio para evitar interferncias consistentes com outros dispositivos. Como
dado na Tabela 8.10, transmissores Bluetooth so classificados em um de trs nveis de potncia, o qual dita a
faixa e o consumo de potncia. No modo da taxa bsica, ele opera a 1 /, utilizando o chaveamento de
frequncia Gaussiana (FSK). No FSK ordinrio, cada bit transportado ao transmitir uma frequncia de ,
onde a frequncia central do canal e um offset de, pelo menos, 115 . A transio abrupta em
frequncias entre os bits consome larguras de banda extras. Na FSK Gaussiana, a mudana na frequncia
suavizada, para fazer melhor uso do espectro. A Figura 8.55 mostra as frequncias sendo transmitidas por uma
sequncia de 0 e 1 num canal de 2402 utilizando-se FSK e GFSK.
775
O mdulo BueSMiRF Silver, mostrado na Figura 8.56, contm um rdio Bluetooth de Classe 2, modem, e
circuitos de interface com um pequeno carto com interface serial. Ele comunica com outro dispositivo
Bluetooth, como um Bluetoth USB dongle conectado ao PC. Ento, ele pode fornecer um link serial wireless
entre um 32 e um PC, similarmente ao link da Figura 8.43, mas sem o cabo. A Figura 8.57 mostra um
esquemtico para esse link. O pino TX do BlueSMiRF conectado ao pino RX do 32, e vice-versa. Os pinos
RTS e CTS so conectados de modo que o BlueSMiRF no necessita de handshaking.
O BlueSMiRF trabalha, por padro, em 115.2 com 8 bits de dados, 1 bit de stop, e sem paridade
ou controle de fluxo. Ele opera em nveis lgicos de 3.3, no sendo necessrio um transceiver -232 para
realizar a conexo com outro dispositivo de 3.3.
Para utilizar a interface, plugue um dongle USB Bluetooth no PC. Ligue o 32 e o BlueSMiRF. O LED
vermelho STAT ir piscar no BlueSMiRF, indicando que est aguardando para realizar uma conexo. Abra o
cone do Buetooth no PC utilize o Assistente para adicionar dispositivo Bluetooth para parear o dongle com
o BlueSMiRF. A senha padro do BlueSMiRF 1234. Anote qual a porta COM est atribuda ao dongle. Ento,
a comunicao pode prosseguir como se estivesse sendo feita por um cabo serial. Note que o dongle
tipicamente opera a 9600 baud e que o PuTTY deve estar configurado corretamente.
Controle de Motores
Outra aplicao principal dos microcontroladores controlar atuadores, como motores. Esta seo
descreve trs tipos de motores: motores DC, servo motores e motores de passo. Os motores DC requerem
uma grande quantidade de corrente, ento, um driver de potncia, como uma Ponte H, deve ser conectada
entre o microcontrolador e o motor. Ele tambm requer um encoder de eixo, se o usuro quiser saber qual
a posio atual do motor. Os servos motores aceitam um sinal modulado por largura de pulso para
especificar sua posio numa faixa limitada de ngulos. Permitem realizar uma interface fcil, mas no so
potentes e no so adequados para rotao contnua. Motores de passo aceitam uma sequncia de pulsos,
cada um deles rodando o motor num ngulo fixo, denominado de passo. Eles so mais caros, e necessitam
de uma ponte H para fornecer corrente, mas a sua posio pode ser precisamente controlada.
776
Os motores podem drenar uma quantidade substancial de corrente, e podem introduzir pequenos picos na
tenso de alimentao do circuito, o que pode perturbar a lgica digital. Um modo de reduzir isso utilizar uma
fonte de alimentao diferente ou uma bateria para o motor, e outra para o circuito de lgica digital.
Figura 8.58 Motor DC
Motores DC
A Figura 8.58 mostra a operao de um motor DC com escovas. O motor um dispositivo de dois terminais.
Ele contm ims permanentes estacionrios que formam o estator, e um eletrom rotativo chamado rotor ou
armadura, conectado ao eixo. A frente do rotor conectada a um anel metlico dividido chamado comutador.
Escovas de metal conectadas aos terminais de potncia (terminais de entrada) so esfregadas contra o coletor,
fornecendo corrente ao eletrom do rotor. Isso induz um campo magntico no rotor, que faz com que o rotor
777
gire para permanecer alinhado com o campo do estator. Uma vez que o rotor tenha girado uma parte do
caminho e se aproximado do alinhamento com o estator, as escovas tocam os lados opostos do coletor,
revertendo o fluxo de corrente e de campo magntico, e fazendo com que o motor continue girando
indefinidamente.
Os motores DC tendem a girar a milhares de rotaes por minuto (RPM) a um torque muito pequeno. A
maioria dos sistemas adiciona um trem de engrenagens para reduzir a velocidade a um nvel mais razovel
e aumentar o torque. Procure por um trem de engrenagens projetado para ser acoplado a seu motor. A
Pittman fabrica uma grande variedade de motores DC de alta qualidade e de acessrios, enquanto os
motores baratos, de brinquedos, so populares entre os hobbystas.
Um motor DC requer tenses e correntes substanciais para fornecer potncia significativa para uma
carga. A corrente deve ser reversvel se o motor tiver a capacidade de girar em ambas as direes. A maioria
dos microcontroladores no pode produzir corrente suficiente para alimentar um motor DC diretamente.
Ao invs disso, eles utilizam uma Ponte H, que, conceitualmente, contm quatro chaves eletricamente
controladas, como mostrado na Figura 8.59 (a). Se a chave A e D esto fechadas, a corrente flui da esquerda
para a direita atravs do motor, e o faz girar numa direo. Se as chaves B e C esto fechadas, a corrente
flui da direita para a esquerda atravs do motor, fazendo-o girar na outra direo. Se A e C ou B e D esto
fechadas, a tenso atravs do motor forada a 0, fazendo com que o motor freie ativamente. Se nenhuma
das chaves est fechada, o motor ir parar naturalmente. As chaves numa ponte H so transstores de
potncia. A ponte H tambm contm alguma lgica digital para convenientemente controlar as chaves.
Quando a corrente no motor muda abruptamente, a indutncia do eletrom do motor induz uma alta
tenso, que pode exceder a tenso de alimentao e danificar os transstores de potncia.
Portanto, muitas pontes H tambm possuem diodos de proteo em paralelo s chaves, como mostrado
na Figura 8.59 (b). Se o pico indutivo conduzido tanto ao terminal do motor acima de ou abaixo da
terra, os diodos entram em conduo, e grampeiam a tenso a um nvel seguro. As pontes H podem dissipar
grandes quantidades de potncia, ento um dissipador de calor pode ser necessrio para mant-la fria.
778
Exemplo 8.28 VECULO AUTNOMO

Projete um sistema no qual um 32 controla dois drives de motores para um carro robtico. Escreva
uma biblioteca de funes para inicializar o driver do motor, e para fazer o carro ir para frente para trs, virar
para esquerda ou para a direita, e parar. Use PWM para controlar a velocidade dos motores.
Figura 8.59 Ponte H
779
Figura 8.60 Controle de motor com ponte H dual
Tabela 8.11 Controle de ponte H
780
Soluo: A Figura 8.60 mostra um par de motores DC controlados por um 32 utilizando uma ponte H dupla
da Texas Instruments, 754410. A ponte H requer uma alimentao lgica 1 de 5 e uma tenso nos
motores, 2, de 4,5 a 36 . Ela tem = 2 e, consequentemente, compatvel com a I/O de 3,3 do
32. Ela pode entregar at 1 de corrente para cada um dos motores. A Tabela 8.11 descreve como as
entradas de cada ponte H controla um motor. O microcontrolador aciona os sinais de ativao com um sinal
PWM para controlar a velocidade dos motores. Ele aciona os quatro outros pinos para controlar a direo de
cada motor.
O PWM configurado para trabalhar a cerca de 781 com um duty cycle variando entre 0 e 100%.
void setspeed(int dutycycle) {

OC1RS = dutycycle; // ativa duty cycleentre 0 e 100
}
void setmotorleft(int dir) { // dir de 1 = frente, 0 = trs

PORTDbits.RD1 = dir; PORTDbits.RD2 = !dir;
}
void setmotorright(int dir) { // dir de 1 = frente, 0 = trs

PORTDbits.RD3 = dir; PORTDbits.RD4 = !dir;
}
void forward(void) {
setmotorleft(1); setmotorright(1); // ambos os motores para frente
}
void backward(void) {
setmotorleft(0); setmotorright(0); // ambos os motores para trs
781
void left(void) {
setmotorleft(0); setmotorright(1); // esquerda para trs, direita para
frente
}
void right(void) {
setmotorleft(1); setmotorright(0); // direita para trs, esquerda para
frente
}
void halt(void) {
PORTDCLR = 0x001E; // turn both motors off by
// clearing RD[4:1] to 0
}
void initmotors(void) {
TRISD = 0xFFE0; // RD[4:0] sao sadas
halt(); // garantir que motores nao estao girando
// configura PWM em OC1 (RD0)
T2CONbits.TCKPS = 0b111; // prescale de 256 para 78.125 KHz
PR2 = 99; // seta perodo para 99+1 ticks =
781.25 Hz
OC1RS = 0; // inicia com sinal de enable baixo
para H-bridge
OC1CONbits.OCM = 0b110; // ativa modulo de comparao de
sada 1 para PWM mode
T2CONbits.ON = 1; // ativa timer 2
OC1CONbits.ON = 1; // ativa PWM
}
782
Figura 8.61 Codificador de eixo (a) disco, (b) sadas em quadratura
No exemplo anterior, no existe um modo de medir a posio de cada motor. improvvel que dois
motores sejam exatamente iguais, ento provvel que um gire ligeiramente mais rpido do que o outro,
fazendo com que o rob se desvie do curso. Para resolver esse problema, alguns sistemas adicionam
codificadores de eixo. A Figura 8.61 (a) mostra um simples codificador de eixo consistindo de um disco com
slots conectados ao eixo do motor. Um LED colocado em um lado e um sensor de luminosidade no outro
lado. O codificador de eixo produz um pulso a cada vez que o vo passa pelo LED. Um microcontrolador pode
contar esses pulsos para medir o ngulo total percorrido pelo eixo. Utilizando dois pares LED/sensor
espaados de pelo menos metade da largura do slot, um codificador de eixo improvisado pode produzir sadas
em quadratura mostradas na Figura 8.61 (b), que indicam a direo que o eixo est girando, bem como o
ngulo para o qual ele est se movendo. Algumas vezes, so adicionados aos codificadores de eixo outro furo,
para indicar quando o eixo est em sua posio de ndice.
Servo Motor
Um servo motor um motor DC integrado com um sistema de engrenagens, um codificador de eixo e
lgica de controle, sendo ele mais fcil de se utilizar. Eles possuem rotao limitada de, tipicamente, 180. A
Figura 8.62 mostra um servo com a tampa removida para revelar as engrenagens. Um servo motor possui
uma interface de trs pinos com alimentao (tipicamente 5 ), terra, e entrada de controle. A entrada de
controle , tipicamente, um sinal de 50 modulado em largura de pulso. O sistema de controle lgico do
783
servo conduz o eixo para uma posio determinada pelo duty cycle da entrada de controle. O codificador
de eixo do servo , tipicamente, um potencimetro rotativo que produz uma tenso dependente da posio
do eixo.
Figura 8.62 Servo motor SG90
Num servo motor tpico com 180 graus de rotao, uma largura de pulso de 0,5 conduz o eixo para
0, 1,5 para 90, e 2,5 para 180. Por exemplo, a Figura 8.63 mostra um sinal de controle com uma
largura de pulso de 1,5 . Levar o servo para fora de sua faixa de movimento pode causar danos
mecnicos. A potncia do servo vem do pino de alimentao, e no do pino de controle, ento o controle
pode ser conectado diretamente a um microcontrolador, sem o uso de uma ponte H. Servo motores so
comumente utilizados em aeromodelos controlados por controle remoto, e pequenos robs, pois eles so
pequenos, leves e convenientes. Encontrar um motor com um datasheet adequado pode ser difcil. O pino
central com um fio vermelho , normalmente, de alimentao, e o fio preto ou marrom normalmente a
terra.
Figura 8.63 Forma de onda de controle do servo
784
Exemplo 8.29 SERVO MOTOR

Projete um sistema com um microcontrolador 32 conduzindo um servo motor para um ngulo
desejado.
Figura 8.64 Controle de servo motor
Soluo: A Figura 8.64 mostra um diagrama de conexes para um servo motor 90. O servo opera com uma
tenso de alimentao de 4,0 -7,2 . Apenas um nico fio necessrio para conduzir o sinal PWM, o qual
pode ser fornecido em nveis de 5 ou 3,3 . O cdigo configura a gerao de PWM utilizando o mdulo de
comparao de sada 1 e define o duty cycle apropriado para o ngulo desejado.
void initservo(void) { // configura PWM em OC1 (RD0)

T2CONbits.TCKPS = 0b111; // prescale de 256 para 78.125 KHz
PR2 = 1561; // define perodo para 1562
// ticks = 50.016 Hz (20 ms)
OC1RS = 117; // define largura de pulso para
// 1.5 ms para centro do servo
OC1CONbits.OCM = 0b110; // define modo de comparao de
785
// sada 1 para modo PWM

T2CONbits.ON = 1; // ativa timer 2
OC1CONbits.ON = 1; // ativa PWM
}
void setservo(int angle) {

if (angle < 0) angle = 0; // Angulo deve estar na faixa de
// 0-180 graus
else if (angle > 180) angle = 180;
OC1RS = 39+angle*156.1/180; // define largura de pulso de
// 39-195 ticks
// (0.5-2.5 ms) baseado no angulo
}
Tambm possvel converter um servo normal num servo de rotao contnua, cuidadosamente o
desmontando, removendo a trava de parada mecnica, e substituindo o potencimetro por um divisor de
tenso fixo. Muitos websites mostram instrues detalhadas para alguns servos particulares. O PWM ir,
ento, controlar a velocidade ao invs da posio, com 1,5 indicando parada, 2,5 indicando velocidade
total num sentido, e 0,5 indicando velocidade total no sentido contrrio. Um servo de rotao contnua
pode ser mais conveniente e mais barato do que um motor DC simples combinado com uma ponte H e um
trem de engrenagens.
Motor de Passo
Um motor de passo avana em passos discretos conforme pulsos so aplicados s entradas alternadas. A
dimenso do passo de, normalmente, poucos graus, permitindo posicionamento preciso e rotao contnua.
Motores de passo menores geralmente vm com dois conjuntos de bobinas chamadas fases, enroladas em
modo bipolar ou unipolar. Motores bipolares so mais potentes e menos caros para um determinado
tamanho, mas necessitam de uma ponte H, enquanto motores unipolares podem ser conduzidos por
transstores agindo como chaves. Essa seo foca no motor de passo mais eficiente, o bipolar.
786
A Figura 8.65 (a) mostra um motor bipolar simplificado com uma dimenso de passo de 90. O rotor um
m permanente com um polo norte e um polo sul. O estator um eletrom com dois pares de bobinas
compondo as duas fases. Motores bipolares de duas fases, portanto, possuem quatro terminais. A Figura 8.65
(b) mostra o smbolo para o motor de passo, modelando as duas bobinas como indutores.
A Figura 8.66 mostra trs sequncias comuns de conduo para um motor bipolar de duas fases. A Figura
8.66 (a) ilustra um wave drive, no qual as bobinas so energizadas na sequncia AB CD BA DC. Note que
BA significa que o enrolamento AB energizado com corrente fluindo na direo oposta. Essa a origem do
nome bipolar. O rotor gira 90 graus a cada passo. A Figura 8.66 (b) ilustra o two-phase-on drive, seguindo o
padro (AB, CD) (BA, CD) (BA, DC) (AB, DC). (AB, CD) indica que ambos os enrolamentos e CD so
energizados simultaneamente. O rotor novamente gira 90 graus a cada passo, mas se alinha metade do
caminho entre as posies dos dois polos. Isso resulta em um maior torque de operao, pois ambos os
enrolamentos esto entregando potncia de uma vez s. A Figura 8.66 (c) ilustra o half-step drive, seguindo o
padro (AB, CD) CD (BA, CD) BA (BA, DC) DC (AB, DC) AB. O rotor gira 45 graus a cada meio passo.
A taxa qual cada padro avana determina a velocidade do motor. Para inverter a direo do motor, as
mesmas sequncias so aplicadas, mas na ordem inversa.
Em um motor real, o rotor possui muitos polos, para fazer o ngulo entre passos menor. Por exemplo, a
Figura 8.67 mostra o AIRPAX LB82773-M1, um motor de passo bipolar com um tamanho de passo de 7,5 graus.
O motor opera com 5 e drena 0,8 atravs de cada enrolamento.
O torque no motor proporcional corrente nos enrolamentos. Essa corrente determinada pela tenso
aplicada, pela indutncia e pela resistncia da bobina. O modo mais simples de operao chamado drive
direto de tenso ou L/R drive, no qual a tenso diretamente aplicada ao enrolamento. A corrente aumenta
at = / com uma constante de tempo determinada por /, como mostrado na Figura 8.68 (a). Ele
trabalha bem para operaes em baixa velocidade. No entanto, em altas velocidades, a corrente no possui
tempo suficiente para atingir o nvel completo, como mostrado na Figura 8.68 (b), e o torque cai.
Um modo mais eficiente de controlar um motor de passo pela modulao em largura de pulso de uma
tenso maior. A alta tenso faz com que a corrente se eleve mais rapidamente, sendo ento desligada (PWM)
para evitar a sobrecarga do motor. A tenso ento modulada ou recortada para manter a corrente perto do
nvel desejado. Isso chamado drive de recorte constante de tenso, e mostrado naFigura 8.68 (c). O
787
controlador utiliza um pequeno resistor, em srie com o motor, como sensor de corrente sendo aplicada,
atravs da medio da queda de tenso no resistor, e aplica um sinal de ativao para que a ponte H desligue
o drive quando a corrente atingir o nvel desejado. A princpio, um microcontrolador poderia gerar as formas
de ondas corretas, mas mais fcil utilizar um controlador de motor de passo. O controlador 297, da ST
Microelectronics, uma escolha conveniente, especialmente quando acoplado ponte H dual 298, que
tem pinos sensveis corrente e uma capacidade de potncia de 2 de pico. Infelizmente, o 298 no est
disponvel em encapsulamento DIP, sendo difcil de conect-lo a uma breadboard. As STs Application Notes
460 e 470 so valiosas referncias para projetistas de motores de passo.
Figura 8.65 (a) Motor de passo bipolar simplificado, (b) smbolo do motor de passo
788
Figura 8.66 Drive de motor bipolar
Figura 8.67 Motor de passo bipolar AIRPAX LB82773-M1
789
Figura 8.68 Drive de corrente direta de motor de passo bipolar: (a) baixa rotao, (b) alta rotao, (c)
alta rotao com drive chopper
Exemplo 8.30 CONTROLE POR ONDA DIRETA DE MOTOR DE PASSO BIPOLAR

Projete um sistema no qual um microcontrolador 32 controla um motor de passo bipolar AIRPAX, a
uma velocidade e direo especificadas, utilizando direct drive.
Soluo: A Figura 8.69 mostra um motor de passo bipolar sendo conduzido diretamente por uma ponte H
controlada por um 32.
790
A funo spinstepper inicializa o array de sequncia com os padres a serem aplicados em [4: 0] para
ser seguida a sequncia de drive direto. Ela aplica o padro seguinte na sequncia, ento espera o tempo
suficiente para rotacionar taxa desejada de revolues por minuto (RPM). Utilizando-se um clock de
20 e uma dimenso de passo de 7,5 graus, com um timer de 16 bits e um prescalar de 256: 1, a faixa
factvel de velocidades 2 - 230 , com a extremidade inferior limitada pela resoluo do timer, e a
extremidade superior limitada pela potncia do motor 82773 1.
Figura 8.69 Drive direto de motor de passo bipolar com ponte H
791
#define STEPSIZE 7.5 // tamanho do passo, em graus
int curstepstate; // procura o estado atual do motor

// de passo na sequencia
void initstepper(void) {
TRISD = 0xFFE0; // RD[4:0] sao saidas
curstepstate = 0;
T1CONbits.ON = 0; // desliga Timer1
T1CONbits.TCKPS = 3; // prescale de 256 para rodar mais
devagar
}
void spinstepper(int dir, int steps, float rpm) {

{ // dir = 0 para frente, 1 = reverso
int sequence[4] = {0b00011, 0b01001, 0b00101, 0b10001};
int step; // sequncia wave drive
PR1 = (int)(20.0e6/(256*(360.0/STEPSIZE)*(rpm/60.0)));
// tempo/passo c/ 20 MHz
// peripheralclock
TMR1 = 0;
T1CONbits.ON = 1; // liga Timer1
for (step = 0; step < steps; step++) {
792
// toma o numero especificado de passos

PORTD = sequence[curstepstate];
// aplica controle de passo atual
if (dir == 0) curstepstate = (curstepstate + 1) % 4;
// determina o proximo estado -frente
else curstepstate = (curstepstate + 3) % 4;
// determina o proximo estado -tras
while (!IFS0bits.T1IF);
// espera o overflow do timer
IFS0bits.T1IF = 0;
// limpa flag de overflowg
}
T1CONbits.ON = 0;
// desliga Timer1 para economizar
// energia quando concludo
}
8.7. SISTEMAS I/O DO PC

Os computadores pessoais (PC) utilizam uma grande variedade em protocolos I/O para propsitos que
incluem memria, discos, redes, cartes de expanso interna, e dispositivos externos. Esses padres I/O
evoluram para oferecer desempenhos muito elevados e para facilitar aos usurios a adio de dispositivos.
Esses atributos vieram custa da complexidade nos protocolos I/O. Essa seo explora os principais padres
I/O utilizados em PC e examina algumas opes para conectar um PC a um circuito lgico digital customizado
ou outro hardware externo.
A Figura 8.70 mostra a placa-me de um PC para um processador com Core 5 ou 7. O processador
encapsulado num land grid array com 1156 pads banhados a ouro para fornecer tenso de alimentao e terra
793
para o processador, e conect-lo memria e aos dispositivos I/O. A placa-me contm os slots de mdulos
de memria DRAM, uma grande variedade de conectores de dispositivos I/O, um conector para a fonte de
alimentao, reguladores de tenso, e capacitores. Um par de mdulos DRAM so conectados atravs de
uma interface 3. Perifricos externos, como teclados ou webcams so conectados atravs da USB.
Cartes de expanso de alto desempenho, como placas grficas, so conectadas atravs do slot PCI Express
x16, enquanto placas de menor desempenho podem utilizar os slots PCI Express x1 ou os mais antigos. O
PC se conecta rede utilizando o jack Ethernet. O disco rgido conectado a uma porta SATA. O restante
desta seo d uma viso geral da operao de cada um desses padres I/O.
Figura 8.70 Placa-me Gigabyte GA-H55M-S2V
Um dos maiores avanos nos padres I/O dos PC tem sido o desenvolvimento de links seriais de alta
velocidade. At recentemente, a maioria dos dispositivos I/O era construda ao redor de links paralelos
consistindo de um grande barramento de dados e um sinal de clock. Conforme a taxa de dados aumentava,
794
a diferena entre os atrasos nos fios do barramento definiam um limite para o quo rpido o barramento podia
trabalhar. Mais ainda, barramentos conectados a mltiplos dispositivos sofriam, na linha de transmisso,
problemas como reflexes e temporizaes diferentes para diferentes cargas. Rudo tambm pode corromper
os dados. Links seriais ponto a ponto eliminam muitos desses problemas. O dado usualmente transmitido
num par diferencial de fios. Os rudos externos que afetam ambos os fios com a mesma intensidade no so
importantes. As linhas de transmisso so simples de serem encerradas, ento, reflexes so pequenas (Veja
Seo A.8 em linhas de transmisso). Nenhum clock enviado explicitamente. Ao invs disso, o clock
recuperado no receptor atravs da anlise da temporizao da transio dos dados. O projeto de links seriais
de alta velocidade um assunto especializado, mas boas interfaces podem rodar a mais de 10 / atravs
de fios de cobre, e a taxas ainda mais rpidas atravs de fibras ticas.
8.7.1. USB
At o meio da dcada de 1990, adicionar um perifrico a um PC requeria algum conhecimento tcnico.
Para adicionar cartes de expanso, era necessrio abrir a caixa, colocar os jumpers nas posies corretas, e
manualmente instalar um driver de dispositivos. Adicionar um dispositivo -232 requeria escolher o cabo
correto, e apropriadamente configurar a taxa de transmisso e os bits de dados, de paridade e de stop. O
Barramento Universal Serial (Universal Serial Bus) USB, desenvolvido pela Intel, IBM, Microsoft, e outros,
simplificou grandemente a adio de novos perifricos, atravs da padronizao dos cabos e dos processos de
configurao do software. Bilhes de perifricos USB so vendidos por ano, atualmente.
O USB 1.0 foi lanado em 1996. Ele utiliza um cabo simples com quatro fios: 5 , , e um par diferencial
de fios para carregar dados. O cabo impossvel de ser conectado para trs ou de cabea para baixo. Ele opera
em at 12 /. Um dispositivo pode puxar at 500 de corrente da porta USB, ento, teclados, mouses,
e outros perifricos podem ser alimentados atravs da porta, ao invs de baterias ou cabos separados de
alimentao.
O USB 2.0, lanado em 2000, atualizou a velocidade para 480 /, executando os fios diferenciais muito
mais rpido. Com o link mais rpido, o USB se tornou prtico para conectar webcams e discos rgidos externos.
As pen drive flash com interface USB tambm substituram os discos flexveis como meios de transferncia de
arquivos entre computadores.
795
O USB 3.0, lanado em 2008, aumentou ainda mais a velocidade para 5 /. Ele usa a mesma forma de
conector, mas o cabo possui mais fios, que operam a uma velocidade muito alta. mais adequado para
conectar discos rgidos de alta performance. Mais ou menos ao mesmo tempo, o USB adicionou uma
qspecificao de carregamento de bateria que impulsionou a alimentao atravs da porta, para aumentar a
velocidade do carregamento de dispositivos mveis.
A simplicidade para o usurio vem com o preo de uma implementao muito mais complexa de hardware
e software. Construir uma interface USB do zero uma grande empreitada. Mesmo escrever um simples
driver de dispositivo moderadamente complexo. O 32 vem com um controlador USB embutido. No
entanto, o driver de dispositivos da Microchip para conectar um mouse ao 32 (disponvel em
microchip.com) possui mais de 500 linhas de cdigo, e est alm do escopo deste Captulo.
8.7.2. PCI e PCI Express
O barramento Peripheral Component Interconnect (PCI) um barramento de expanso desenvolvido pela
Intel, que se tornou muito difundido em meados de 1994. Ele era utilizado para adicionar cartes de
expanso como portas USB ou seriais extras, interfaces de rede, placas de som, modems, controladores de
disco, ou placas de vdeo. O barramento paralelo de 32 bits opera a 33 , dando uma largura de banda
de 133 /.
A demanda pelos cartes de expanso PCI vem caindo constantemente. Mais portas padro, como
Ethernet e SATA so agora integrados placa-me. Muitos dispositivos que antes necessitavam de um carto
de expanso podem agora ser conectados atravs de um rpido link USB 2.0 ou 3.0. E placas de vdeo
atualmente requerem muito mais largura de banda do que a PCI pode fornecer.
Placas-me contemporneas frequentemente ainda possuem um pequeno nmero de slots PCI, mas
dispositivos rpidos, como placas de vdeo, agora so conectadas via PCI Express (PCIe). Slots PCI Express
fornecem uma ou mais vias de links seriais de alta velocidade. No PCIe 3.0, cada via opera em at 8 /. A
maioria das placas-me fornece um slot x16 com 16 vias, resultando n um total de 16 / de largura de
banda para dispositivos com grande exigncia de dados, como as placas de vdeo.
796
8.7.3. Memrias DDR3

A DRAM conectada ao microprocessador atravs de um barramento paralelo. Em 2012, o padro atual
o 3, a terceira gerao de barramentos de memria de taxa de dados double, operando a 1,5 . Placas-
me tpicas agora vm com dois canais 3, de modo que podem acessar dois bancos de memrias
simultaneamente.
A Figura 8.71 mostra um mdulo de memria do tipo dual inline (DIMM), 3, 4. O mdulo possui 120
contatos de cada lado, com um total de 240 conexoes, incluindo um barramento de dados de 64-bits. Um
barramento de endereos multiplexados em tempo de 16-bits, sinais de controle, e vrios pinos de alimentao
e terra. Em 2012, as DIMM tipicamente carregavam de 1 a 16-GB de DRAM. A capacidade de memria vem
sendo dobrada a aproximadamente 2 ou 3 anos.
Figura 8.71 Mdulo de memria DDR3
Atualmente, a opera a uma taxa de clock de 100 a 266 . A 3 opera o barramento de

memria a quatro vezes a taxa de clock da DRAM. Mais ainda, ela transfere os dados em ambas as bordas de
subida e descida do clock. Consequentemente, ela envia 8 palavras de dado para cada clock da memria. A 64
bits/palavra, isso correspond e a 6,4-17 / de largura de banda. Por exemplo, a 3 1600 utiliza um
clock de memria de 200 e um clock I/O de 800 para enviar 1.6 bilho de palavras por segundo, ou
12800 /. Consequentemente, os mdulos so tambm chamados 3 12800. Infelizmente a latncia
da DRAM permanece alta, com cerca de 50 de atraso da leitura de uma requisio at a chegada da primeira
palavra de dados.
797
8.7.4. Rede
Computadores se conectam Internet atravs de uma interface de rede rodando o Transmission Control
Protocol e Internet Protocol (TCP/IP). A conexo fsica pode ser um cabo Ethernet ou um link wireless Wifi.
Tabela 8.12 Protocolos Wi-Fi 802.11
A Ethernet definida pelo padro 802.3. Ele foi desenvolvido pelo Xerox Palo Alto Research Center
(PARC) em 1974. Foi originalmente operado a 10 / (denominado 10 Mbit Ethernet), mas agora
comumente encontrado a 100 / e 1 / rodando em cabos de Categoria 5 contendo 4 pares de fios.
O padro Ethernet de 10 com cabos de fibra tica vem se tornando crescentemente popular em
servidores e outros tipos de computao de alta performance, e a Ethernet 100 est emergindo.
Wi-Fi o nome popular para o padro de redes wireless 802.11. Ele opera nas bandas wireless no
licenciadas de 2,4 e 5 , o que significa que o usurio no necessita de uma licena de operador de rdio
para transmitir nessas bandas a potncia reduzida. A Tabela 8.12 resume as capacidades das trs geraes
de Wi-Fi; o padro emergente 802.11 promete empurrar as taxas wireless para acima de 1 /. O
desempenho crescente vem dos avanos na modulao e no processamento de sinais, mltiplas antenas e
maiores largura de bandas dos sinais.
798
8.7.5. SATA
Discos rgidos internos requerem uma rpida interface com o PC. Em 1986, a Western Digital introduziu a
interface Integrated Drive Electronics (IDE), que evoluiu para o padro AT Attachment (ATA). O padro utiliza
um volumoso cabo de fita de 40 ou 80 fios, com um comprimento mximo de 18", para enviar dados a 16
133 /.
Figura 8.72 Cabo SATA
O padro ATA vem sendo substitudo pelo Serial ATA (SATA), que utiliza links seriais de alta velocidade para
trabalhar a 1,5, 3, ou 6 /, utilizando um mais conveniente cabo de 7-condutores, mostrado na Figura 8.72.
Os drives em estado slido mais rpidos em 2012 se aproximaram de 500 / de largura de banda, tomando
plena vantagem da interface SATA.
Um padro relacionado o Serial Attached SCSI (SAS), uma evoluo da interface SCSI paralela (Small
Computer System Interface). A SAS oferece um desempenho comparado ao SATA e aceita cabos maiores. mais
comum em servidores de computadores.
8.7.6. Interface com o PC
Todos os padres I/O do PC descritos at agora so otimizados para alto desempenho e facilidade de ligao,
mas so difceis de serem implementadas em hardware. Engenheiros e cientistas frequentemente precisam de
um modo de conectar um PC a circuitos externos, como sensores, atuadores, microcontroladores, ou FPGA. A
799
conexo serial descrita na Seo 8.6.3 suficiente para uma conexo de baixa velocidade com um
microcontrolador com uma UART. Essa seo descreve dois outros modos: sistemas de aquisio de dados e
links USB.
Sistemas de Aquisio de Dados
Os Sistema de Aquisio de Dados (DAQ) conectam um computador ao mundo real, utilizando mltiplos
canais de entradas analgicas e/ou digitais. Os DAQ so agora comumente disponveis como dispositivos
USB, fazendo com que sejam simples de serem instalados. A National Instruments (NI) uma fabricante lder
no ramo dos DAQ.
Figura 8.73 NI myDAQ
Figura 8.74 Cabo FTDI USB para MPSSE
800
Os preos dos DAQ de alta performance tendem a milhares de dlares, principalmente porque o mercado
pequeno e possui concorrncia limitada. Felizmente, a partir de 2012, a NI tem vendido seu sistema myDAQ
com um desconto para estudantes de $200, incluindo o software LabView. A Figura 8.73 mostra um myDAQ.
Ele possui dois canais analgicos com capacidade de entrada e sada a 200 ksamples/s, com 16-bits de resoluo,
e uma faixa dinmica de 10 . Esses canais podem ser configurados para operarem como um osciloscpio e
gerador de sinais. Ele tambm possui oito linhas digitais de entradas e sadas compatveis com sistemas de 3,3 e
5 . Mais ainda, ele gera sadas de alimentao de +5, +15 e 15 , e inclui um multmetro digital capaz de
medir tenso, corrente e resistncia. Ento, o myDAQ pode substituir uma bancada inteira de testes e
equipamentos de medio, enquanto simultaneamente, oferece data logging automtico.
A maioria dos NI DAQ so controlados com o LabVIEW, a linguagem grfica da NI para o projeto de sistemas
de controle e de medio. Alguns DAQ tambm podem ser controlados atravs de programas em C utilizando-
se o ambiente LabWindows, de aplicaes em Microsoft .NET utilizando o ambiente Measurement Studio, ou
do Matlab, usando o Toolbox Data Acquisition.
Links USB
Uma crescente variedade de produtos agora disponibiliza links digitais entre PC e hardware externo atravs
de USB simples e baratos. Esses produtos contm drivers e bibliotecas pr-desenvolvidos, permitindo ao usurio
facilmente escrever um programa no PC que intercambie dados entre o PC e uma FPGA ou microcontrolador.
801
Figura 8.75 Interface do C232HM-DDHSL USB para MPSESE, do PC para FPGA
Figura 8.76 Mdulo FTDI UM232H
A FTDI lder em vendas de tais sistemas. Por exemplo, o cabo USB para MPSSE 232
, mostrado na Figura 8.74, fornece um jack USB numa extremidade e, na outra extremidade, uma
interface SPI operando a at 30 /, juntamente com uma alimentao de 3,3 e quatro pinos I/O de
propsito geral. A Figura 8.75 mostra um exemplo de conexo entre um PC e uma FPGA utilizando esse cabo.
802
O cabo pode, opcionalmente, alimentar o FPGA com 3,3 . Os trs pinos SPI so conectados a um dispositivo
FPGA escravo como aquele do Exemplo 8.19. A figura tambm mostra um dos pinos GPIO usado para controlar
um LED.
O PC requer que o controlador de biblioteca dinamicamente ligada, 2, esteja instalado. Voc pode,
ento, escrever um programa em C utilizando a biblioteca para enviar dados atravs do cabo.
Se uma conexo ainda mais rpida necessria, o mdulo 232 mostrado na Figura 8.76 liga a
porta USB do PC a uma interface paralela sncrona de 8-bits operando a at 40 /.
8.8. PERSPECTIVA DO MUNDO REAL: MEMRIA X86 E SISTEMAS I/O

Conforme um processador fica mais rpido, ele necessita sempre de uma hierarquia de memria mais
elaborada, para manter um suprimento permanente de dados e o fluxo de instrues. Esta seo descreve os
sistemas de memria dos processadores 86 para ilustrar essa progresso. A Seo 7.9 contm fotografias dos
processadores, destacando as caches on-chip. Os 86 tambm possuem um sistema de I/O programada
invulgar, que difere das I/O mais comuns, mapeadas na memria.
8.8.1. Sistemas de Cache x86
O 80386, inicialmente produzido em 1985, operava a 16 . Ele no tinha cache, ento acessava
diretamente a memria principal para todas as instrues e dados. Dependendo da velocidade da memria, o
processador poderia ter uma resposta imediata, ou teria que que fazer uma pausa de um ou mais ciclos para a
memria reagir. Esses ciclos so chamados estados de espera, e aumentam a CPI do processador. As
frequncias de clock dos microprocessadores tm crescido pelo menos 25% por ano desde ento, enquanto a
latncia de memria dificilmente vem diminundo. O atraso de quando o processador envia um endereo para
a memria principal at a memria retornar o dado pode, atualmente, exceder 100 ciclos de clock do
processador. Portanto, caches com uma baixa miss rates so essenciais para um bom desempenho. A Tabela
8.13 resume a evoluo dos sistemas de cache nos processadores Intel 86.
803
Tabela 8.13 Evoluo dos sistemas de memria dos microprocessadores Intel X86
O 80486 introduziu uma cache unificada write-through que mantinha tanto instrues quanto dados. A
maioria dos sistemas computacionais de alto desempenho tambm fornecia uma cache de segundo nvel
maior na placa-me, utilizando chips de SRAM comercialmente disponveis, que eram substancialmente mais
rpidos que a memria principal.
O processador Pentium introduziu as caches separadas para dados e instrues, para evitar conteno
durante requisies simultneas para dados e instrues. As caches utilizavam uma poltica de write-back,
reduzindo a comunicao com a memria principal. Novamente, um segundo nvel de cache maior
(tipicamente 256 512 ) era oferecido na placa-me.
804
Figura 8.77 Mdulo Pentium Pro multichip com o processador (esquerda) e um cache de 256 kB (direita),
em um encapsulamento PGA (Cortesia Intel)
A srie 6 de processadores (Pentium Pro, Pentium II e Pentium III) foi projetada para frequncias de clock
muito mais elevadas. A cache de segundo nvel na placa-me poderia no ser mantida, sendo ento movida
para perto do processador para melhorar a sua latncia e taxa de transferncia. O Pentium Pro era
encapsulado num modulo multichip (MCM) contendo tanto o chip do processador quanto o chip da cache de
segundo nvel, como mostrado na Figura 8.77. Assim como no Pentium, o processador tinha caches de nvel 1
separados para dados e instrues. No entanto, essas caches eram nonblocking, de modo que o processador
fora de funcionamento poderia continuar a executar subsequentes acessos cache mesmo se a cache falhasse
num particular acesso, e tivesse que buscar o dado na memria principal. A cache de segundo nvel era de
256 , 512 ou 1 de tamanho, e podia operar mesma velocidade do processador. Infelizmente, o
805
encapsulamento MCM provou-se muito caro para fabricao em volumes elevados. Por esse motivo, o
Pentium II foi vendido num cartucho de menor custo, que continha o processador e a cache de segundo
nvel. As caches de nvel 1 foram dobradas em tamanho para compensar o fato de que a cache de segundo
nvel operava metade da velocidade do processador. O Pentium III integrava uma cache de segundo nvel
de velocidade completa diretamente sobre o mesmo chip do processador. Uma cache no mesmo chip pode
operar com uma melhor latncia e taxa de transferncia, ento, substancialmente mais efetiva do que uma
cache de mesmo tamanho, mas fora do chip.
O Pentium 4 oferecia uma cache nonblocking de primeiro nvel de dados. Ele era chaveado com uma
cache de troca para armazenar instrues aps ter sido decodificado em micro operaes, evitando o atraso
de recodificar cada uma das instrues buscadas na cache.
O projeto do Pentium M foi adaptado do Pentium III. Ele aumentou ainda mais a cache de nvel 1 para
32 cada, e destacou uma cache 2 de a 1 a 2 . O Core Duo contm dois processadores Pentium M
modificados e uma cache compartilhada de 2 em chip. A cache compartilhada til para a comunicao
entre os processadores: um pode escrever dados na cache, e o outro pode l-los.
O projeto do Nehalem (Core 3-7) adicionou um terceiro nvel de cache compartilhada entre todos os
ncleos com o fim de facilitar o compartilhamento de informao entre ncleos. Cada ncleo possui a sua
prpria cache 1 de 64 e cache 2 de 256 , enquanto a cache compartilhada 3 contm de 4 a 8 .
8.8.2. Memria Virtual x86
Processadores 86 operam tanto em Modo Real quanto em Modo Protegido. Modo Real compatvel
com o original 8086. Ele utiliza apenas 20 bits de endereo, limitando a memria para 1 , e no aceita
memria virtual.
O Modo Protegido foi introduzido com o 80286 e estendido para endereos de 32-bits com o 80386. Ele
suporta memrias virtuais com pginas de 4 . Tambm fornece proteo de memria, de modo que um
programa no pode acessar as pginas pertencentes a outros programas. Consequentemente, um programa
defeituoso ou malicioso no pode quebrar ou corromper outros programas. Todos os sistemas operacionais
modernos utilizam atualmente esse modo.
806
Um endereo de 32-bits permite at 4 de memria. Processadores desde o Pentium Pro tm

aumentado a capacidade de memria para 64 atravs do uso de uma tcnica chamada extenso de
endereo fsico. Cada processo usa endereos de 32-bits. O sistema de memria virtual mapeia esses
endereos sobre um espao maior de memria, de 36-bits. Ele utiliza diferentes tabelas de pginas para cada
processo, de modo que cada processo pode ter o seu prprio espao de endereos de at 4 .
Para contornar esse gargalo na memria de uma forma mais elegante, 86 tem sido atualizada para 86-
64, o qual oferece endereos virtuais e registradores de propsitos gerais de 64-bits. Atualmente, apenas 48
bits de endereo virtual so utilizados, fornecendo um espao de endereos virtuais de 256 (terabyte). O
limite pode ser estendido para os completos 64-bits como expanso de memria, oferecendo uma
capacidade de 16 (exabyte).
8.8.3. I/O Programada para x86
A maioria das arquiteturas utiliza I/O de memria mapeada, descrita na Seo 8.5, nas quais os programas
acessam dispositivos I/O atravs da leitura e da escrita em endereos de memria. A 86 utiliza I/O
programada, na qual instrues especiais IN e OUT so utilizadas para ler e escrever em dispositivos I/O. A
86 define 216 portas I/O. A instruo IN l um, dois, ou quatro bytes da porta especificada por DX em AL, AX,
ou EAX, OUT possui funcionamento similar, mas escreve na porta.
Conectar um dispositivo perifrico a um sistema I/O programado similar a conect-lo a um sistema de
memria mapeada. Quando acessamos uma porta I/O, o processador envia o nmero de porta ao invs do
endereo de memria nos 16 bits menos significativos do barramento de endereos. O dispositivo l ou
escreve dados do barramento de dados. A diferena principal que o processador tambm produz um sinal
. Quando /
/ = 1, o processador est acessando a memria. Quando 0, o processador est
acessando um dos dispositivos I/O. O decodificador de endereos deve tambm olhar para / para gerar
os sinais de ativao apropriados a memria principal e par aos dispositivos I/O. Dispositivos I/O podem
tambm enviar interrupes para o processador, para indicar que elas esto prontas para se comunicarem.
807
8.9. SUMRIO
A organizao de sistemas de memria um fator principal na determinao do desempenho do
computador. Diferentes tecnologias de memria, tais como DRAM, SRAM, e discos rgidos, oferecem
compromissos em capacidade, velocidade e custo. Este Captulo introduziu as organizaes de memrias
cache e virtual que utilizam uma hierarquia de memrias para se aproximarem de uma memria ideal,
grande, rpida e barata. A memria principal tipicamente construda a partir da DRAM, a qual
significativamente mais lenta que o processador. Uma cache reduz o tempo de acesso mantendo na SRAM
rpida os dados comumente utilizados. A memria virtual aumenta a capacidade de memria atravs do
uso de um disco rgido para armazenar dados que no cabem na memria principal. Caches e memria
virtual adicionam complexidade e hardware a um sistema computacional, mas os benefcios usualmente
prevalecem sobre os custos. Todos os computadores pessoais modernos utilizam caches e memrias
virtuais. A maioria dos processadores tambm utiliza a interface de memria para realizar a comunicao
entre dispositivos I/O. Ela chamada I/O de memria mapeada. Programas utilizam operaes de
carregamento e armazenamento para acessar os dispositivos I/O.
EPLOGO
Esse Captulo nos traz at o final de nossa jornada juntos pelo reino dos sistemas digitais. Esperamos
que este livro tenha passado a beleza e a emoo da arte tanto quanto o conhecimento em engenharia. O
leitor aprendeu a projetar sistemas lgicos combinatrios e sequenciais utilizando diagramas esquemticos
e linguagens de descrio de hardware. Est familiarizado com os blocos maiores, como multiplexadores,
ULA e memrias. Computadores so uma das muitas fascinantes aplicaes dos sistemas digitais. O leitor
aprendeu a programar um processador MIPS na sua linguagem assembly nativa, e como construir o sistema
do processador e memria utilizando blocos de construo digitais. Do incio ao fim, viu aplicaes da
808
abstrao, disciplina, hierarquia, modularidade e regularidade. Com essas tcnicas, juntamos todas as peas
do quebra-cabeas do funcionamento interno de um microprocessador. De telefones celulares s televises
digitais, os Mars rovers, os sistemas de imagens mdicas, nosso mundo um lugar cada vez mais digital.
Imagine que o Charles Babbage faria para realizar uma jornada parecida h um sculo e meio atrs. Ele
aspirava apenas calcular tabelas matemticas com precises mecnicas. Os sistemas digitais de hoje so a
fico cientfica de ontem. Talvez Dick Tracy tenha utilizado o iTunes em seu celular? Ser que Julio Verne
podia ter lanado uma constelao de satlites de posicionamento global no espao? Poderia Hipcrates
ter curado doenas utilizando imagens digitais em alta resoluo do crebro? Porm, ao mesmo tempo, o
pesadelo de George Orwell, da vigilncia do governo onipresente, se torna mais prxima a cada dia. Hackers
e governos travam guerras digitais no declaradas, atacando as infraestruturas industriais e as redes
financeiras. E estados desonestos desenvolvem armas nucleares utilizando computadores portteis mais
poderosos do que os supercomputadores do tamanho de uma sala que simularam as bombas da Guerra
Fria. A revoluo do microprocessador continua a acelerar. As mudanas nas prximas dcadas iro superar
aquelas do passado. O leitor possui agora as ferramentas para projetar e construir esses novos sistemas que
iro moldar o nosso futuro. Junto com seus novos poderes acrescem profundas responsabilidades. Temos
a esperana de que vai us-los, no apenas por diverso e riqueza, mas tambm para o benefcio da
humanidade.
809
Exerccios
Exerccio 8.1 Em menos de uma pgina, descreva quatro atividades dirias que exibem localidade
temporal ou espacial. Liste duas atividades para cada tipo de localidade, e seja especfico.
Exerccio 8.2 Num pargrafo, descreva duas pequenas aplicaes computacionais que exibem localidade
temporal e/ou espacial. Descreva quais. Seja especfico.
Exerccio 8.3 Apresente uma sequncia de endereos para os quais uma cache mapeada diretamente
com um tamanho (capacidade) de 16 palavras e um tamanho de bloco de 4 palavras supera uma cache
totalmente associativa com substituio do menos recentemente usado (LRU) com mesma capacidade e
tamanho de bloco.
Exerccio 8.4 Repita o Exerccio 8.3 para o caso em que uma cache completamente associativa supera a
cache mapeada diretamente.
Exerccio 8.5 Descreva os compromissos de se aumentar cada um dos parmetros da cache enquanto se
mantm os outros constantes:
(a) Tamanho de bloco
(b) Associatividade
(c) Tamanho da cache
810
Exerccio 8.6 A miss rate de uma cache associativa de duas vias, usualmente, ocasionalmente, ou nunca
melhor do que uma cache mapeada diretamente de mesma capacidade e tamanho de bloco? Explique.
Exerccio 8.7 Cada uma das seguintes declaraes pertence miss rate das caches. Marque cada declarao
como verdadeira ou falsa. Explique brevemente o seu raciocnio. Apresente um contra-exemplo se a
declarao for falsa.
(a) Uma cache associativa de duas vias sempre possui uma miss rate menor do que a de uma cache mapeada
diretamente com o mesmo tamanho de bloco e capacidade total.
(b) Uma cache diretamente mapeada de 16 sempre possui uma miss rate menor do que uma cache
diretamente mapeada de 8 com o mesmo tamanho de bloco.
(c) Uma cache de instrues com um bloco de 32 bytes usualmente possui uma miss rate menor do que um
cache de instrues com um tamanho de bloco de 8 bytes, dados o grau de associatividade e a capacidade
total.
Exerccio 8.8 Uma cache possui os seguintes parmetros: , tamanho do bloco, em nmero de palavras; ,
nmero de conjuntos; nmero de vias; e , nmero de bits de endereo.
(a) em termos dos parmetros descritos, qual a capacidade da cache, ?
(b) Em termos dos parmetros descritos, qual o nmero total de bits necessrios para armazenar as tags?
(c) Quais so e para uma cache totalmente associativa de capacidade palavras com um tamanho de
bloco ?
(d) Qual para uma cache diretamente mapeada de tamanho palavras e tamanho de bloco ?
811
Exerccio 8.9 Uma cache de 16 palavras possui os parmetros dados no Erro! A origem da referncia no
foi encontrada.. Considere a seguinte sequncia repetida de lw endereos (dados em hexadecimal):
40 44 48 4 70 74 78 7 80 84 88 8 90 94 98 9 0 4 8 10 14 18 1 20
Assumindo substituio do menos recentemente usado (LRU) para caches associativas, determine a miss
rate efetiva, se a sequncia a entrada das seguintes caches: ignorando os efeitos de inicializao (perdas
compulsrias, por exemplo):
(a) Cache diretamente mapeada, = 1 palavra
(b) Cache totalmente associativa, = 1 palavra
(c) Cache de conjunto associativa duas vias, = 1 palavra
(d) Cache diretamente mapeada, = 2 palavras
Exerccio 8.10 Repita o Exerccio 8.9 para a seguinte sequncia repetida de lw endereos (dados em
hexadecimal) e configuraes de cache. A capacidade da cache mantm-se de 16 palavras.
74 10 78 38 84 88 8 7 34 38 13 388 18
(a) Cache diretamente mapeada, = 1 palavra
(b) Cache totalmente associativa, = 2 palavras
(c) Cache associativa de conjunto duas vias, = 2 palavras
(d) Cache diretamente mapeada, = 4 palavras
Exerccio 8.11 Suponha que est rodando um programa com o seguinte padro de acesso de dados. O
padro executado apenas uma vez:
00 08 010 018 020 028

812
(a) Se o leitor utilizar uma cache com mapeamento direto com um tamanho de cache de 1 kB e um
tamanho de bloco de 8 bytes (2 palavras), quantos conjuntos existem na cache?
(b) Com a mesma cache e tamanho de bloco de dados na parte (a), qual a miss rate da cache mapeada
diretamente para o padro de acesso memria dado?
(c) Para o dado padro de acesso memria, qual das seguintes afirmaes poderia diminuir a miss rate
da maioria? (a capacidade da cache mantida constante). Circule uma.
i) Aumentando o grau de associatividade para 2.
ii) Aumentando o tamanho do bloco para 16 bytes.
iii) Tanto (i) quanto (ii).
iv) Nem (i) nem (ii).
Exerccio 8.12 O leitor est construindo uma cache de instrues para um processador MIPS. Ela possui
a capacidade total de 4 = 2+2 bytes. Sendo associativa de conjunto com = 2 vias ( 8), com um

tamanho de bloco de = 2 bytes ( 8). Em termos destes parmetros, d as suas respostas para as
questes seguintes.
(a) Quais os bits de endereo utilizados para selecionar uma palavra dentro do bloco?
(b) Quais os bits de endereo utilizados para selecionar o conjunto na cache?
(c) Quantos bits existem em cada tag?
(d) Quantos tag bits existem em toda a cache?
Exerccio 8.13 Considere uma cache com os seguintes parmetros: (associatividade) = 2, (tamanho
de bloco)= 2 palavras, (tamanho da palavra) = 32 bits, (tamanho da cache) = 32 palavras,
(tamanho de endereo) = 32 bits. Voc precisa considerar apenas os endereos de palavras.
813
(a) Mostre o tag, conjunto, offset de bloco, e bits do byte offset do endereo. Indique quantos bits so
necessrios para cada campo.
(b) Qual o tamanho de todas as tags de cache nos bits?
(c) Suponha que cada bloco de cache tambm tenha um bit vlido () e um dirty bit (). Qual o tamanho
de cada conjunto de cache, incluindo dados, tags, e bits de status?
(d) Projete a cache utilizando os blocos de construo da Figura 8.78 e um pequeno nmero de portas
lgicas de duas entradas. O projeto da cache deve incluir armazenamento de tags, armazenamento de
palavras, comparao de endereos, seleo de dados de sada, e qualquer outras partes que o leitor ache
relevantes. Note que os blocos do multiplexador e do comparador podem ter qualquer tamanho ( ou
bits, respectivamente), mas os blocos SRAM devem ter 16 4 bits. Tenha a certeza de incluir um diagrama
de blocos ntido e com legendas. Voc precisa projetar a cache apenas para leituras.
Figura 8.78 Blocos de construo
Exerccio 8.14 O leitor se juntou a uma nova e hot startup de Internet para construir relgios de pulso
com pager e navegor web embutido. Ele utiliza um processador embarcado com um esquema de cache
multi-nvel, mostrado na Figura 8.79. O processador inclui uma pequena cache on-chip, juntamente com
uma grande cache off-chip (Sim, esse relgio pesa 1.3, mas voc deveria v-lo funcionando!).
Assuma que o processador utiliza endereos fsicos de 32-bits, mas acessa os dados apenas das fronteiras
das palavras. As caches possuem as caractersticas dadas na Tabela 8.14. A DRAM possui um tempo de
acesso de e um tamanho de 512 .
814
(a) Para uma dada palavra na memria, qual o nmero total de localizaes em que ela pode ser
encontrada na cache on-chip e na cache de segundo nvel?
(b) Qual o tamanho, em bits, de cada tag para a cache on-chip e para a cache de segundo nvel?
(c) D uma expresso para o tempo mdio de acesso memria. As caches so acessadas em sequncia.
(a) Medidas mostraram que, para um particular problema de interesse, a hit rate da cache on-chip de
85%, e a hit rate da cache de segundo nvel de 9. %. No entanto, quando a cache on-chip
desativada, a hit rate da cache de segundo nvel sobe para 98,5%. D uma breve explicao para esse
comportamento.
Tabela 8.14 Caractersticas de memria
Figura 8.79 Sistema computacional

815
Exerccio 8.15 Este Captulo descreveu a poltica de substituio do menos recentemente utilizado (LRU)
para caches associativas multi-vias. Outra, menos comum, poltica de substituio, incluem a first-in-first-
out (FIFO) e as polticas aleatrias. A substituio por FIFO evita o bloco que l est h mais tempo,
independente do quo recentemente ele foi acessado. A substituio aleatria evita um bloco
aleatoriamente.
(a) Discuta as vantagens e desvantagens de cada uma destas polticas de substituio.
(b) Descreva um padro de acesso de dados para o qual a FIFO teria uma melhor realizao do que a
LRU.
Exerccio 8.16 O leitor est construindo um computador com um sistema hierrquico de memria que
consiste em caches separados para instrues e dados, seguidas pela memria principal. O leitor est
utilizando o processador MIPS multi-ciclos da Figura 8.41, trabalhando a 1 .
(a) Suponha que a cache de instrues perfeita (isto , sempre acerta), mas a cache de dados possui
uma miss rate de 5%. Num erro de cache, o processador espera 60 para acessar a memria principal,
e ento volta operao normal. Levando as falhas de cache em considerao, qual o tempo mdio de
acesso memria?
(b) Quantos ciclos de clock por instruo (CPI), em mdia, so necessrios para carregar e armazenar
instrues de palavras, considerando um sistema de memria no ideal?
(c) Considerando a aplicao de referncia do Exemplo 7.7 que possui 25% de carregamentos, 10% de
armazenamentos, 11% de branches, 2% de saltos, e 52% de instrues tipo-R. Levando em conta o
sistema de memria no ideal, qual a CPI mdia para esta aplicao?
(d) Agora suponha que a cache de instrues tambm no ideal, e possui uma miss rate de 7%. Qual
a CPI mdia para a aplicao na parte (c)? Leve em conta que ambas as caches de instrues e de dados
falham.
816
Exerccio 8.17 Repita o Erro! A origem da referncia no foi encontrada. com os seguintes parmetros.
(a) Suponha que a cache de instrues perfeito (isto , sempre acerta), mas a cache de dados possui
uma miss rate de 15%. Num erro de cache, o processador espera 200 para acessar a memria principal,
e ento volta operao normal. Levando as falhas de cache em considerao, qual o tempo mdio de
acesso memria?
(b) Quantos ciclos de clock por instruo (CPI), em mdia, so necessrios para carregar e armazenar
instrues de palavras, considerando um sistema de memria no ideal?
(c) Considerando a aplicao de referncia do Exemplo 7.7 que possui 25% de carregamentos, 10% de
armazenamentos, 11% de branches, 2% de saltos, e 52% de instrues tipo-R. Levando em conta o sistema
de memria no ideal, qual a CPI mdia para esta aplicao?
(d) Agora suponha que a cache de instrues tambm no ideal, e possui uma miss rate de 10%. Qual
a CPI mdia para a aplicao na parte (c)? Leve em conta que ambas as caches de instrues e de dados
falham.
Exerccio 8.18 Se um computador utiliza endereos virtuais de 64-bits, quanto de memria virtual ele
pode acessar? Note que 240 bytes = 1 terabyte, 250 bytes 1 petabyte, e 260 bytes = 1 exabyte.
Exerccio 8.19 Um projetista de supercomputadores escolhe gastar $1 milho em DRAM, e a mesma

quantia em discos rgidos para memria virtual. Utilizando os preos da Figura 8.4, quanto de memria fsica
e virtual o computador ter? Quantos bits de endereo fsicos e virtuais so necessrios para se acessar a
memria?
Exerccio 8.20 Considere um sistema de memria virtual que pode enderear um total de 232 -bytes. O
leitor possui um espao ilimitado de disco rgido, mas est limitado em apenas 8 de memria
semicondutora (fsica). Assuma que as pginas fsicas e virtuais possuem de tamanho, cada.
817
(a) De quantos bits endereo fsico?

(b) Qual o nmero mximo de pginas virtuais no sistema?
(c) Quantas pginas fsicas h no sistema?
(d) De quantos bits o nmero de pginas fsicas e virtuais?
(e) Suponha que o leitor apresenta um esquema mapeado diretamente que mapeia as pginas virtuais
em pginas fsicas. O mapeamento utiliza os bits menos significativos do nmero de pgina virtual para
determinar o nmero de pgina fsico. Quantas pginas virtuais so mapeadas para cada endereo fsico?
Por que esse plano de mapeamento direto um plano ruim?
(f) Claramente, um esquema mais dinmico e flexvel para traduzir endereos virtuais em fsicos
necessrio ao invs daquele descrito na parte (e). Suponha que o leitor utiliza uma tabela de pginas para
armazenar mapeamentos (tradues de nmeros de pginas virtuais para nmeros de pginas fsicas).
Quantas entradas a tabela de pginas ir conter?
(g) Assuma que, alm do nmero de pginas fsicas, cada tabela de pginas contm tambm alguma
informao de status na forma de um bit vlido () e um dirty bit (). Quantos bytes possui cada entrada
da tabela de pginas? (Arredonde para o maior nmero inteiro de bytes).
(h) Esboce o layout da tabela de pginas. Qual o tamanho total, em bytes, da tabela de pginas?
Exerccio 8.21 Considere um sistema de memria virtual que pode enderear um total de 250 -bytes. O
leitor possui um espao ilimitado no disco rgido, mas limitado em 2 de memria semicondutora
(fsica). Assuma que as pginas fsicas e virtuais possuem, cada uma 4 de tamanho.
(a) De quantos bits o endereo fsico?
(b) Qual o mximo nmero de pginas virtuais no sistema?
(c) Quantas pginas fsicas existem no sistema?
818
(d) De quantos bits o nmeros de pginas fsicas e virtuais?

(e) Quantas entradas na tabela de pginas ir a tabela de pginas conter?
(f) Assuma que, alm do nmero de pginas fsicas, cada tabela de pginas contm tambm alguma
informao de status na forma de um bit vlido () e um dirty bit (). Quantos bytes possui cada entrada da
tabela de pginas? (Arredonde para o maior nmero inteiro de bytes).
(g) Esboce o layout da tabela de pginas. Qual o tamanho total da tabela de pginas, em bytes?
Exerccio 8.22 O leitor decide aumentar a velocidade do sistema de memria virtual do Exerccio 8.20
utilizando um translation lookaside buffer (TLB). Suponha que o seu sistema de memria tem as
caractersticas mostradas na Tabela 8.15. O TLB e a miss rate da cache indicam o quo frequentemente a
entrada requisitada no foi encontrada. A miss rate da memria principal indica o quo frequentemente uma
falha de pgina ocorre
(a) Qual o tempo mdio de acesso memria do sistema de memria virtual, antes e depois da adio
do TLB? Assuma que a tabela de pginas reside sempre na memria fsica e nunca mantida na cache de
dados.
(b) Se o TLB possui 64 entradas, qual o tamanho (em bits) do TLB? D os nmeros para dados (nmero de
pgina fsica), tag (nmero de pgina virtual), e bits vlidos para cada entrada. Mostre o seu trabalho
claramente.
(c) Esboce o TLB. Rotule claramente todos os campos e dimenses.
(d) Para construir o TLB descrito na parte (c), voc precisaria de uma SRAM de que tamanho? D sua
resposta em termos de profundidade largura.
819
Tabela 8.15 Caractersticas de memria
Exerccio 8.23 O leitor decide aumentar a velocidade do sistema de memria do Exerccio 8.21 utilizando
um TLB de 128 entradas.
(a) Qual o tamanho (em bit) do TLB? D os nmeros para dados (nmero de pgina fsica), tag (nmero
de pgina virtual), e bits vlidos para cada entrada. Mostre o seu trabalho claramente.
(b) Esboce o TLB. Rotule claramente todos os campos e dimenses.
(c) Para construir o TLB descrito na parte (b), voc precisaria de uma SRAM de que tamanho? D sua
resposta em termos de profundidade largura.
Exerccio 8.24 Suponha que o processador MIPS multi-ciclos descrito na Seo 7.4 utiliza um sistema de
memria virtual.
(a) Esboce a localizao do TLB no esquemtico do processador multi-ciclos.
(b) Descreva como a insero de um TLB afeta o desempenho do processador.
820
Exerccio 8.25 O sistema de memria virtual que voc est projetando utiliza uma tabela de pginas de
nvel nico, construda a partir de hardware dedicado (SRAM e lgica associada). Ele suporta endereos
virtuais de 25-bits, endereos fsicos de 22-bits., e pginas de 216 -bytes (64). Cada entrada da tabela de
pginas contm um nmero de pgina fsica, um bit vlido () e um dirty bit ().
(a) Qual o tamanho total da tabela de pginas, em bits?
(b) A equipe do sistema operacional props a reduo do tamanho de pgina de 64 para 16 , mas
os engenheiros de hardware da sua equipe atentaram para o aumento no custo do hardware. Explique o
porqu dessa objeo.
(c) A tabela de pginas deve ser integrada ao chip do processador, juntamente com a cache on-chip. A
cache on-chip lida apenas com endereos fsicos (no virtuais). possvel acessar o conjunto apropriado na
cache on-chip ao mesmo tempo que a tabela de pginas para um dado acessa a memria? Explique
brevemente a relao que necessria para acessar simultaneamente o conjunto da cache e a entrada da
tabela de pginas.
(d) possvel realizar uma comparao de tags numa cache on-chip simultaneamente ao acesso a tabela
de pginas para um dado acesso memria? Explique brevemente.
Exerccio 8.26 Descreva um cenrio no qual um sistema de memria virtual pode afetar como uma
aplicao escrita. Tenha certeza de incluir uma discusso de como o tamanho da pgina e o tamanho da
memria fsica afetam o desempenho da aplicao.
Exerccio 8.27 Suponha que voc tenha um computador pessoal (PC) que utiliza endereos virtuais de 32-
bits.
(a) Qual a quantidade mxima de espao de memria virtual que cada programa pode utilizar?
(b) De que modo o tamanho do disco rgido do seu PC afeta o desempenho?
821
(c) De que modo o tamanho da memria fsica do seu PC afeta o desempenho?
Exerccio 8.28 Utilize uma I/O MIPS mapeada em memria para interagir com o usurio. Cada vez que
usurio pressiona o boto, um padro de sua escolha mostrado em cinco diodos emissores de luz (LED).
Suponha que o boto de entrada mapeado para o endereo 010 e os LED so mapeados para o
endereo 014. Quando o boto pressionado, a sada 1. Caso contrrio, a sada 0.
(a) Escreva um cdigo MIPS para implementar essa funcionalidade.
(b) Desenhe um esquemtico para esse sistema I/O mapeado em memria.
(c) Escreva o cdigo HDL para implementar o decodificador de endereos para o seu sistema I/O
mapeado em memria.
Exerccio 8.29 Mquinas de estados finitos (FSM), assim como aquelas construdas no Captulo 3, podem
tambm ser implementadas em software.
(a) Implemente a FSM do semforo da Figura 3.25 utilizando cdigo assembly MIPS. As entradas ( e
) so mapeadas em memria para bit 1 e bit 0, respectivamente, do endereo 0000. As duas
sadas de 3-bits ( e ) so mapeadas para os bits 0-2 e bits 3-5, respectivamente, do endereo
0004. Assuma codificao de sada one-hot para cada lmpada, e ; vermelho 100, amarelo
010 e verde 001.
(b) Desenhe um esquemtico para esse sistema I/O mapeado em memria.
(c) Escreva o cdigo HDL para implementar o decodificador de endereos para o seu sistema I/O mapeado
em memria.
Exerccio 8.30 Repita o Exerccio 8.29 para a FSM na Figura 3.30 (a). A entrada e a sada so mapeadas
em memria para os bits 0 e 1, respectivamente, do endereo 0040.
822
Os seguintes exerccios apresentam questes que vm sendo perguntadas em entrevistas.
Pergunta 8.1 Explique a diferena entre caches associativas de conjunto, mapeadas diretamente e
completamente associativas. Para cada tipo de cache, descreva uma aplicao em que um tipo de cache
melhor do que os outros dois.
Pergunta 8.2 Explique como um sistema de memria virtual funciona.
Pergunta 8.3 Explique as vantagens e desvantagens de se usar um sistema de memria virtual.
Pergunta 8.4 Explique como o desempenho da cache pode ser afetado pelo tamanho de pgina virtual de
um sistema de memria.
Pergunta 8.5 Endereos utilizados em I/O de memria mapeada podem ser utilizados em caches? Explique
porque sim ou porque no.
823
824
A Implementao de Sistemas
Digitais
A.1 INTRODUO
Este apndice apresenta questes prticas na concepo de sistemas digitais. O material no necessrio
para a compreenso do resto do livro, no entanto, procura desmistificar o processo de construo de
sistemas digitais reais. Alm disso, acreditamos que a melhor maneira de compreender os sistemas digitais
construir e os depurar sozinho no laboratrio.
Os sistemas digitais so geralmente construdos utilizando um ou mais chips. Uma estratgia fazer a
ligao entre chips contendo portas lgicas individuais ou elementos maiores, como unidades
aritmticas/lgicas (ALUs) ou memrias. Outro a utilizao de lgica programvel, que contm as
matrizes genricas de circuito que podem ser programadas para realizar as funes lgicas especficas.
Ainda uma terceira a concepo de um circuito integrado personalizado que contm a lgica especfica
necessria para o sistema. Estas trs estratgias oferecem compensaes em termos de custo, velocidade,
consumo de energia e tempo de projeto que so exploradas nas Sees a seguir. Este apndice tambm
examina o empacotamento fsica e montagem de circuitos, as linhas de transmisso que conectam os
chips, e a economia dos sistemas digitais.
A.2 LGICA 74XX

Nos anos 1970 e 1980, muitos sistemas digitais foram construdos a partir de chips simples, cada um
contendo um punhado de portas lgicas. Por exemplo, o chip de 7404 contm seis portas NOT, o 7408
825
Apndice A Implementao de Sistemas Digitais
possui quatro portas AND, e o 7474 contm dois flip-flops. Esses chips so coletivamente referidos
como a lgica da srie 74xx. Eles foram vendidos por muitos fabricantes, geralmente por 10 a 25
centavos de dlar por chip. Estes chips so agora completamente obsoletos, mas ainda so teis nos
sistemas digitais ou em projetos acadmicos simples, dado que so baratos e fceis de usar. Os chips
da srie 74xx so comumente vendidos em pacotes Dual Inline Packcage (DIP) de 14 pinos.
A.2.1 Portas Lgicas
A Figura A.1 mostra os diagramas de pinout para uma variedade de chips populares da srie 74xx
contendo portas lgicas bsicas. Estes so algumas vezes chamados de chips de integrao de
pequena escala (SSI Small Scale Integration), porque so construdos a partir de alguns transstores.
Os pacotes de 14 pinos tm tipicamente um entalhe na parte superior ou um ponto na parte superior
esquerda para indicar a orientao. Os pinos so numerados comeando com 1 no canto superior
esquerdo e no sentido anti-horrio em torno do pacote. Os chips precisam receber alimentao (VDD
= 5 V) e terra (GND = 0 V) nos pinos 14 e 7, respectivamente. O nmero de portas lgicas sobre o chip
determinado pelo nmero de pinos. Note-se que os pinos 3 e 11 do chip 7421 no esto conectados
(NC Not Connected). O flip-flop 7474 tem os tpicos terminais D, CLK e Q. Tambm tem uma sada
complementar, : Alm disso, recebe sinais de set assncrono (tambm chamado de preset ou PRE)
e de reset (tambm chamado clear, ou CLR). Estes so ativos a baixo; por outras palavras, o flip-flop
= 0, repe quando
fica ativo quando =
= 0, e opera normalmente quando = 1.
A.2.2 Outras Funes
A srie 74xx tambm inclui funes lgicas um pouco mais complexas, incluindo as mostradas na
Figura A.2 e na Figura A.3. Estes so chamados de chips de integrao de mdia escala (MSI medium
scale integration). A maioria usa pacotes maiores para acomodar mais entradas e sadas. A
alimentao e a terra ainda so fornecidas no canto superior direito e inferior esquerdo,
respectivamente, de cada chip. A descrio funcional geral fornecida para cada chip. Veja as folhas
de dados do fabricante para obter descries completas.
826
A.3 LGICA PROGRAMVEL

A lgica programvel consiste em matrizes de circuito que podem ser configurados para realizar
as funes lgicas especficas. J introduzimos trs formas de lgica programvel: memrias
programveis de apenas leitura (PROM), dispositivos de lgica programvel (PLA Programmable
Logic Arrays) e Field Programmable Gate Array (FPGA). Esta seo apresenta implementaes de
chips para cada uma delas. A configurao destes chips pode ser realizada por queima dos fusveis
on-chip para ligar ou desligar os elementos do circuito. Isso chamado de lgica One-Time
Programmable (OTP), porque, uma vez que um fusvel esteja queimado, ele no pode ser restaurado.
Alternativamente, a configurao pode ser armazenada numa memria que pode ser reprogramada
vontade. A lgica reprogramvel conveniente em laboratrio, porque o mesmo chip pode ser
reutilizado durante o desenvolvimento.
A.3.1 PROM
Como discutido na Seco 5.5.7, as PROM podem ser usadas como tabelas de consulta. Uma
PROM de 2N-palavras M-bits pode ser programada para executar qualquer funo de combinaes
de N entradas e M sadas. As alteraes de projeto envolvem apenas a substituio do contedo da
PROM em vez da religao das ligaes entre os chips. As tabelas de pesquisa so teis para pequenas
funes, mas torna-se proibitivamente caro com o aumento do nmero de entradas.
827
Figura A.1 Portas lgicas da srie 74xx
828
Nota: os nomes de variveis em SystemVerilog no podem comear com nmeros, mas os nomes no
cdigo de exemplo na Figura A.2 so escolhidos para coincidir com a folha de dados do fabricante.
Figura A.2 Chips de integrao de mdia escala
829
Figura A.3 Mais chips de integrao de mdia escala (MSI)

830
Figura A.4 EPROM de 8KB 2764
Por exemplo, a clssica PROM 2764 apagvel de 8 KB (64 KB) (EPROM), mostrada na Figura A.4.
A EPROM tem 13 linhas de endereo para especificar uma das 8K palavras e 8 linhas de dados para
ler o byte de dados dessa palavra. O ativar do chip e da sada devem ser acionados para os dados a
serem lidos. O atraso mximo de propagao de 200 ps. Em operao normal,
= 1 e no
utilizado. A EPROM geralmente programada num programador especial que define = 0,
aplica 13 V a , e usa uma sequncia especial de entradas para configurar a memria.
As PROM modernas so similares no conceito, mas tm capacidades muito maiores e mais pinos.
A memria flash do tipo mais barato de PROM, vendido por cerca de US $1 por gigabyte em 2012.
Os preos historicamente diminuem de 30 a 40% ao ano.
831
A.3.2 PLA
Como discutido na Seo 5.6.1, as PLA contm planos de AND e OR para determinar qualquer
funo combinatria escrita na forma de soma de produtos. Os planos de AND e OR podem ser
programados usando as mesmas tcnicas das PROM. A PLA tem duas colunas para cada entrada e
uma coluna para cada sada. Ela tem uma linha para cada mintermo. Esta organizao mais
eficiente do que uma PROM para muitas funes, mas o array ainda se torna excessivamente grande
para funes com vrios I/O e mintermos.
Diferentes fabricantes estenderam o conceito bsico da PLA para construir dispositivos lgicos
programveis (PLD), que incluem registros. A 22V10 uma das PLD clssicas mais populares. Ela
tem 12 pinos de entrada dedicados e 10 sadas. As sadas podem vir diretamente da PLA ou a partir
de registros de clock no chip. As sadas tambm podem ser alimentadas de volta para a PLA. Assim,
a 22V10 pode implementar diretamente uma FSM com at 12 entradas, 10 sadas e 10 bits de
estado. A 22V10 custa cerca de US $ 2 em quantidades de 100. As PLD foram tornando-se obsoletas
pelas rpidas melhorias na capacidade e custo das FPGA.
A.3.3 FPGA
Como discutido na Seo 5.6.2, as FPGA consistem em matrizes de elementos lgicos (LE logic
element) configurveis, tambm chamados de blocos lgicos configurveis (CLB configurable logic
block), ligados entre si com fios programveis. Os LE contm pequenas tabelas de pesquisa e flip-
flops. As FPGA escalam graciosamente para capacidades extremamente grandes, com milhares de
tabelas de pesquisa. A Xilinx e a Altera so duas das principais fabricantes de FPGA.
As tabelas de pesquisa e os fios programveis so flexveis o suficiente para implementar
qualquer funo lgica. No entanto, eles tm uma ordem de magnitude menos eficiente na
velocidade e no custo (rea de chip) do que as verses hard-wired das mesmas funes. Assim,
muitas vezes as FPGA incluem blocos especializados, tais como memrias, multiplicadores, e at
mesmo microprocessadores inteiros.
A Figura A.5 mostra o processo de concepo de um sistema digital num FPGA. O projeto
geralmente especificado com uma linguagem de descrio de hardware (HDL), embora algumas
ferramentas para FPGA tambm suportam esquemas. O projeto ento simulado. As entradas so
832
aplicadas e comparadas com os resultados esperados para verificar que a lgica est correta.
Normalmente, necessria uma depurao. A seguir, a sntese lgica converte o HDL em funes
Booleanas. Boas ferramentas de sntese produzem um esquema das funes, e o designer prudente
examina esses esquemas, bem como quaisquer avisos produzidos durante a sntese, para garantir que
a lgica desejada foi produzida. s vezes, a codificao descuidada leva a circuitos que so muito
maiores do que o pretendido ou a circuitos com lgica assncrona. Quando os resultados de sntese
so bons, a ferramenta para FPGA mapeia as funes para o LE de um chip especfico. A funcionalidade
posiciona e roteia determina quais as funes em cada tabela de pesquisa e como so ligadas entre
si. O atraso do condutor aumenta com o comprimento, os circuitos crticos devem ser colocados
juntos. Se o projeto grande demais para caber no chip, ele deve ser recriado.
A anlise temporal compara as restries de tempo (por exemplo, uma velocidade de relgio
pretendida de 100 MHz) contra os atrasos de circuitos reais e relata quaisquer erros. Se a lgica
muito lenta, pode ter que ser redesenhada ou um pipeline diferente deve ser utilizado. Quando o
projeto est correto, um arquivo gerado especificando o contedo de todos os LE e a programao
de todos os fios na FPGA. Muitas FPGA armazenam essas informaes de configurao numa memria
RAM esttica que deve ser recarregado de cada vez que a FPGA ligada. A FPGA pode baixar esta
informao de um computador no laboratrio, ou pode l-la a partir de uma ROM no voltil quando
a energia aplicada pela primeira vez.
Exemplo A.1 ANLISE TEMPORAL DE UMA FPGA

Alyssa P. Hacker usa uma FPGA para implementar um classificador de M&M com um sensor de cor Figura A.5 Fluxo de projecto
e motores para colocar os doces vermelhos num frasco e os doces verdes noutro. O seu projeto utilizando uma FPGA
implementado com uma FSM, e ela est usando uma Cyclone IV GX. De acordo com a folha de dados,
a FPGA tem as caractersticas de temporizao apresentados na Tabela A.1.
A Alyssa gostaria que a sua FSM fosse executada a 100 MHz. Qual o nmero mximo de LE no
caminho crtico? Qual a velocidade mais rpida a que sua FSM pode executar?
833
Soluo: A 100 MHz, o tempo de ciclo, Tc, 10 ns. Alyssa usa a Equao 3.13 para descobrir o atraso
mnimo de propagao, tpd, neste tempo de ciclo:
10 (0,199 + 0,076) = 9,725 (A.1)
Com um atraso combinado do LE e do condutor de 381 ps + 246 ps = 627 ps, a FSM da Alyssa, no
mximo, deve usar 15 LE consecutiva (9,725 / 0,627) para implementar a lgica de prximo estado.
A maior velocidade qual uma FSM pode ser executada nesta FPGA Cyclone IV quando utiliza um
nico LE para a prxima lgica estado. O tempo de ciclo mnimo
381 + 199 + 76 = 656 (A.2)
Portanto, a frequncia mxima de 1,5 GHz.
Tabela A.1 Temporizao da Cyclone IV GX
A Altera anunciou a FPGA Cyclone IV com 14.400 LE por US $ 25 em 2012. Em grandes

quantidades, as FPGA mdias normalmente custam vrios dlares. As FPGA maiores custam
centenas ou mesmo milhares de dlares.
834
A.4 CIRCUITOS INTEGRADOS DE USO ESPECFICO

Os ASIC so chips projetados para um uso particular. Os aceleradores grficos, chips de interface de
rede e chips de telefones celulares so exemplos comuns de ASICS. O projetista de ASIC coloca os
transstores para criar conjuntamente as portas lgicas e as respectivas ligaes. Dado que o ASIC
programado para uma funo especfica, tipicamente vrias vezes mais rpido do que uma FPGA e
ocupa uma ordem de magnitude menos rea de pastilha (e, portanto, o custo) do que uma FPGA com a
mesma funo. No entanto, as mscaras especificando onde transstores e as suas ligaes esto
localizados no chip custam centenas de milhares de dlares para produzir. O processo de fabricao
requer geralmente 6 a 12 semanas para fabricar, embalar, e testar os ASIC. Se os erros so descobertos
aps o ASIC ser fabricado, o projetista deve corrigir o problema, gerando novas mscaras, e aguarde que
um outro lote seja fabricado. Assim, os ASIC so adequados apenas para os produtos que vo ser
produzidos em grandes quantidades e cuja a funo bem definida previamente.
A Figura A.6 mostra o processo de criao de um ASIC, que semelhante ao processo de criao da
FPGA da Figura A.7. A lgica de verificao especialmente importante porque a correo de erros aps
as mscaras serem produzidas dispendioso. A sntese produz uma netlist que consiste em portas
lgicas e ligaes entre as portas; as portas nesta netlist so colocadas, e as ligaes so encaminhadas
entre as portas. Quando o desenho satisfatrio, as mscaras so geradas e utilizadas para fabricar o
ASIC. Uma nica partcula de poeira pode arruinar um ASIC, pelo que os chips devem ser testados aps
a fabricao. A frao de chips fabricados que funcionam chamada de rendimento; tipicamente 50 a
90%, dependendo do tamanho do chip e do processo de fabrico. Finalmente, os chips operacionais so
colocados em embalagens, como ser discutido na Seco A.7.
A.5 DATA SHEETS

Os fabricantes de circuitos integrados publicam folhas de dados (data sheets) que descrevem as
Figura A.6 Sequncia de projeto ASIC
funes e o desempenho dos seus chips. essencial ler e compreender as folhas de dados. Uma das
principais fontes de erros em sistemas digitais vem de no perceber o funcionamento de um chip.
835
As folhas de dados esto geralmente disponveis a partir do Web site do fabricante. Se o leitor no
conseguir localizar a folha de dados para um componente e no tm documentao clara de outra
fonte, no use o componente. Algumas das entradas na folha de dados pode ser enigmtica. Muitas
vezes o fabricante publica livros de dados contendo folhas de dados para muitos componentes
relacionados. Algumas das entradas na folha de dados pode ser enigmtica. O incio do livro de dados
tem informaes de esclarecimento adicional. Esta informao pode ser encontrada na web com
uma pesquisa cuidadosa.
Esta Seo disseca a folha de dados para o chip inversor 74HC04 da Texas Instruments (TI). A folha
de dados relativamente simples, mas ilustra muitos dos elementos principais. A TI ainda fabrica
uma ampla variedade de chips da srie 74xx. No passado, muitas outras empresas construram esses
chips tambm, mas o mercado est se consolidando com o declnio de vendas.
A Figura A.7 mostra a primeira pgina da folha de dados. Algumas das sees principais so
destacadas em azul. O ttulo SN54HC04, SN74HC04 HEX INVERTERS. HEX INVERTERS significa que o
chip contm seis inversores. SN indica que a TI o fabricante. Outros cdigos de fabricao incluem
MC para Motorola e DM para a National Semiconductor. Geralmente, o leitor pode ignorar esses
cdigos, porque todos os fabricantes disponibilizam lgica de srie 74xx compatvel. HC a famlia
lgica (alta velocidade CMOS). A famlia lgica determina a velocidade e o consumo de energia do
chip, mas no a funo. Por exemplo, os chips 7404, 74HC04, e 74LS04 contm todos seis inversores,
mas diferem em desempenho e custo. Outras famlias lgicas so discutidas na Seo A.6. Os chips
74xx operar em toda a gama de temperaturas comercial ou industrial (0 a 70 C ou de -40 a 85 C,
respectivamente), ao passo que os chips 54xx operam em toda a gama militar de temperaturas (-55
a 125 C) e so vendidos por um preo mais elevado, mas so apesar disso compatveis.
O 7404 est disponvel em muitos pacotes diferentes, e importante para quando o leitor faz uma
compra. Os pacotes so distinguidos por um sufixo no nmero de pea. O N indica um pacote PDIP
(plastic dual inline package), que se encaixa numa breadboard ou pode ser soldada through-holes
numa placa de circuito impresso. Outros empacotamentos so descritos na Seco A.7.
836
A tabela funcional mostra que cada porta inverte a sua entrada. Se A est a High (H), Y est a Low
(L), e vice-versa. O quadro trivial neste caso, mas mais interessante para chips mais complexos.
A Figura A.8 mostra a segunda pgina da ficha de dados. O diagrama lgico indica que o chip contm
inversores. A seco absolute maximum indica as condies para alm das quais o chip poder ser
destrudo. Em particular, a tenso de alimentao (VCC, tambm chamado VDD neste livro) no deve
ser superior a 7 V. A corrente contnua de sada no deve exceder os 25 mA. A resistncia trmica ou
impedncia, JA, utilizada para calcular o aumento de temperatura causado por dissipao de energia
no chip. Se a temperatura ambiente na vizinhana do chip TA e o chip dissipa Pchip, em seguida, a
temperatura no prprio chip na sua juno com o pacote ser
= + (A.3)
Por exemplo, se um chip 7404, num pacote DIP de plstico, est a funcionar dentro de uma caixa
aquecida a 50 C e consome 20 mW, a temperatura da juno ir subir para 50 C + 0,02 W 80 C/ W
= 51,6 C. A dissipao de energia interna raramente importante para os chips da srie 74xx, mas
torna-se importante para os chips modernos que dissipam dezenas de watts ou mais.
837
Figura A.7 Pgina 1 do data sheet do 7404
838

839
As condies de operao recomendadas definem o ambiente no qual o chip deve ser usado.
Dentro destas condies, o chip deve observar as especificaes. Estas condies so mais rigorosas
do que os mximos absolutos. Por exemplo, a tenso de alimentao deve estar compreendida entre
2 e 6 V. Os nveis lgicos de entrada para a famlia lgica HC depende de VDD. Use as entradas de 4,5
V, quando VDD = 5 V, para permitir uma queda de 10% no fornecimento de energia provocado pelo
rudo no sistema.
A Figura A.9 mostra a terceira pgina da ficha de dados. As caractersticas elctricas descrevem
como o dispositivo funciona quando usado dentro das condies de operao recomendadas, se as
entradas so mantidas constantes. Por exemplo, se a VCC = 5 V (e desce para 4,5 V) e a corrente de
sada IOH / IOL no excede os 20 , VOH = 4,4 V e 0,1 V = VOL no pior dos casos. Se a sada de corrente
aumenta, a tenso de sada se torna menos ideal, porque os transstores no chip lutam para fornecer
a corrente. A famlia lgica HC usa transstores CMOS que exigem muito pouca corrente. A corrente
em cada entrada garantida ser menor do que 1000 nA e , tipicamente, de apenas 0,1 nA
temperatura ambiente. A corrente de alimentao de repouso (IDD) exigida enquanto o chip est
ocioso menor que 20 . Cada entrada tem menos do que 10 pF de capacidade.
As caractersticas de comutao definem como o dispositivo funciona quando usado dentro das
condies de operao recomendadas, se as entradas mudam. O atraso de propagao, tpd, medido
a partir da entrada, quando passa atravs de 0,5 VCC para quando a sada passa atravs de 0,5 VCC. Se
VCC , nominalmente, 5 V e o chip lida com uma capacidade de menos de 50 pF, o atraso de
propagao no ser superior a 24 ns (e, tipicamente, ser muito mais rpido). Lembre-se que cada
entrada pode apresentar 10 pF, de modo que o chip no pode dirigir mais de cinco chips idnticos
velocidade mxima. Na verdade, a capacidade parasita das ligaes dos chips diminui mais a carga
til. O tempo de transio, tambm chamado de tempo de subida/descida, medido como as
transies de sada entre 0,1 VCC e 0,9 VCC.
Lembre-se da Seo 1.8 que os chips consomem tanto potncia esttica como dinmica. A energia
esttica baixa para circuitos HC. A 85 C, a corrente de alimentao de quiescente mxima 20 .
A 5 V corresponde um consumo de energia esttica de 0,1 mW. A potncia dinmica depende da
capacitncia com que lida e a frequncia de comutao. O 7404 tem uma capacidade de dissipao
de energia interna de 20 pF por inversor. Se todos os seis inversores do 7404 comutam a 10MHz e
840
lidam com cargas externas de 25 pF, ento a potncia dinmica dada pela Equao 1.4 (6) (20 pF
+ 25 pF) (52) (10 MHz) = 33,75 mW e a potncia total mxima de 33,85 mW.

841
A.6 FAMLIA LGICAS

Os chips lgicos da srie 74xx foram fabricados com muitas tecnologias diferentes, chamadas de
famlias lgicas, que oferecem diferentes compromissos de velocidade, potncia e nvel lgico.
Outros chips so normalmente concebidos para serem compatveis com algumas destas famlias
lgicas. Os chips originais, tais como o 7404, foram construdos utilizando transstores bipolares numa
tecnologia chamada Transistor-Transistor Logic (TTL). As tecnologias mais recentes adicionam uma
ou mais letras depois do 74 para indicar a famlia lgica, como 74LS04, 74HC04, ou 74AHCT04. A
Tabela A.2 resume as famlias mais comuns de lgica 5 V.
Os avanos nos circuitos bipolares e na tecnologia de processo levaram Schottky (S) e s famlias
Low-Power Schottky (LS). Ambas so mais rpidas do que a TTL. A Schottky exige mais energia,
enquanto a Low-Power Schottky consome menos. A Schottky Advanced (AS) e a Advanced Low-Power
Schottky (ALS) melhoraram a velocidade e a potncia em comparao com a S e a LS. A lgica fast (F)
mais rpida e consome menos energia do que a AS. Todas estas famlias fornecem mais corrente
para as sadas a LOW do que para sadas a HIGH e, portanto, tm nveis lgicos assimtricos. Elas
esto em conformidade com os nveis lgicos "TTL": VIH = 2V, VIL = 0,8 V, VOH> 2,4 V, e VOL <0,5 V.
Como os circuitos CMOS amadureceram nos anos 1980 e 1990, eles se tornaram populares porque
eles exigem pouca energia ou corrente de entrada. As famlias High Speed CMOS (HC) e Advanced
High Speed CMOS (AHC) exigem quase nenhuma potncia esttica. Elas tambm entregam a mesma
corrente para sadas HIGH e LOW. Esto em conformidade com os nveis lgicos "CMOS": VIH = 3.15
V, VIL = 1,35 V, VOH> 3,8 V, e VOL <0,44 V. Infelizmente, estes nveis so incompatveis com circuitos
TTL, porque uma sada a HIGH TTL de 2,4 V pode no ser reconhecida como uma entrada CMOS HIGH
vlida. Isso motiva o uso da lgica High Speed TTL compatvel com a CMOS (HCT) e Advanced High
Speed TTL compatvel com CMOS (ACTH), que aceitam nveis lgicos de entrada TTL e geraram nveis
lgicos de sada CMOS vlidos. Estas famlias so ligeiramente mais lentas do que as suas homlogas
CMOS puras. Todos os chips CMOS so sensveis descarga eletrosttica (ESD - electrostatic
discharge), causada pela eletricidade esttica. Por isso, deve-se tocar num grande objeto de metal
antes de manusear os chips CMOS.
842
Tabela A.2 Especificaes tpicas para famlias lgicas de tenso reduzida
A lgica da srie 74xx barata. As famlias lgicas mais recentes so muitas vezes mais baratas
do que as obsoletas. A famlia LS amplamente disponvel e robusta e uma escolha popular para
projetos de laboratrio ou passatempo que no tm necessidades especiais de desempenho.
O padro de 5 V entrou em colapso em meados dos anos 1990, quando os transstores se
tornaram pequeno demais para suportar a tenso. Alm disso, a tenso mais reduzida permite um
menor consumo de energia. Agora, 3,3, 2,5, 1,8, e 1,2 V so as tenses mais baixas usadas
comumente. A pletora de tenses coloca desafios na comunicao entre os chips com diferentes
843
fontes de alimentao. A Tabela A.3 lista algumas das famlias lgicas de baixa tenso. Nem todos
os dispositivos 74xx esto disponveis em todas estas famlias lgicas.
Tabela A.3 Especificaes tpicas para famlias lgicas de baixa tenso
Todas as famlias lgicas de tenso reduzida usam transstores CMOS, o cavalo de trabalho dos
modernos circuitos integrados. Eles operam sobre uma vasta gama de VDD, mas a velocidade
degrada a tenso mais reduzida. A lgica Low-Voltage CMOS (LVC) e a lgica Advanced Low-Voltage
CMOS (ALVC) so comumente usadas em 3,3, 2,5, ou 1,8 V. A LVC permite entradas at 5,5 V, para
que possa receber entradas de circuitos 5-V CMOS ou TTL. A lgica Advanced Ultra-Low-Voltage
CMOS (AUC) comumente usado em 2,5, 1,8, ou 1,2 V e excepcionalmente rpida. Tanto a ALVC
como a AUC suportam entradas at 3,6 V, para que possam receber entradas de circuitos 3,3 V.
As FPGA muitas vezes oferecem fontes de tenso separadas para a lgica interna, chamada de
ncleo, e para pinos de entrada/sada (I/O). Como as FPGA tm evoludo, a tenso do ncleo caiu
844
de 5 para 3,3, 2,5, 1,8, e 1,2 V para economizar energia e evitar danificar os transstores muito
pequenos. As FPGA tm I/O configurvel para que possam operar a tenses diferentes, de modo a
serem compatveis com o resto do sistema.
A.7 EMPACOTAMENTO E MONTAGEM

Os circuitos integrados so normalmente colocados em embalagens de plstico ou cermica. O
empacotamento tem vrias funes, incluindo ligar os pequenos pinos de metal do I/O do chip aos
pinos maiores no pacote para facilidade de ligao, protegendo o chip de danos fsicos, e dissipar o
calor gerado pelo chip sobre uma rea maior para ajudar a refrigerar. Os pacotes so colocados numa
placa de ensaio ou placa de circuito impresso e ligados entre si para a montagem do sistema.
Empacotamento
A Figura A.10 mostra uma variedade de pacotes de circuitos integrados. Os pacotes podem ser
geralmente classificados como Through-hole ou Surface Mount (SMT). Os through-hole, como o seu
nome indica, tm pinos que podem ser inseridos atravs de furos numa placa de circuito impresso ou
em socket. Os Dual Inline Packages (DIP) tm duas fileiras de pinos com espaamento de 0,1
polegadas entre pinos. O Pin Grid Arrays (PGA) suporta mais pinos num empacotamento mais
pequeno, colocando os pinos na parte inferior do pacote. O empacotamento SMT soldado
diretamente na superfcie de uma placa de circuito impresso sem o uso de furos. Os pinos no
empacotamento SMT so chamado de leads. O empacotamento Thin Small Outline Package (TSOP)
tem duas linhas de leads espaadas (espaamento tipico de 0,02 polegadas). Os Plastic Leaded Chip
Carriers (PLCC) tm ligaes em forma de J em todos os quatro lados, com espaamento de 0,05
polegadas. Eles podem ser soldados directamente a uma placa ou colocados em encaixes especiais.
Os Quad Flat P(QFP) acomodam um elevado nmero de pinos, utilizando pinos em todos os quatro
lados. Os Ball Grid Arrays (BGA) eliminam completamente os pinos. Em vez disso, tm centenas de
pequenas bolas de solda na parte inferior do empacotamento. So cuidadosamente colocados sobre
os correspondentes pads na placa de circuito impresso, que, em seguida, aquecida de modo a que
a solda derreta e una o pacote placa de base.
845
Figura A.10 Empacotamento de circuitos integrados
Breadboard
Os DIP so fceis de utilizar em prototipagem, porque podem ser colocados numa breadboard. A
breadboard de plstico contm as linhas de bases, como mostrado na Figura A.11. Todos os cinco furos
numa fileira esto ligados entre si. Cada pino do pacote colocado num orifcio de uma linha separada.
Os fios podem ser colocados em furos adjacentes na mesma linha para fazer ligaes ao pino. A
breadboard fornecem muitas vezes colunas separadas de furos conectados, no topo da placa para
distribuio de energia e terra.
846
Figura A.11 Circuito numa breadboard
A Figura A.11 mostra uma placa de ensaio contendo uma porta maioria construda com um chip
AND 74LS08 e um chip OR 74LS32. O esquema do circuito mostrado na Figura A.12. Cada porta no
esquema rotulada com o chip (08 ou 32) e os nmeros dos pinos das entradas e sadas (ver Figura
A.1). Observa-se que as mesmas conexes so feitas na placa de ensaio. As entradas esto ligadas aos
pinos 1, 2 e 5 do chip 08, e a sada observada no pino 6 do chip 32. A alimentao e a terra so
ligadas aos pinos 14 e 7, respectivamente, de cada chip, a partir das colunas verticais de alimentao
e de terra que esto ligadas s tomadas de ficha de banana, Vb e Va. Rotulando o esquema desta
maneira, e verificando as conexes como elas so realizadas, uma boa forma de reduzir o nmero
de erros cometidos durante a construo do circuito.
847
Infelizmente, fcil ligar acidentalmente um fio no buraco errado ou um fio cair, ento a utilizao
de breadboards requer uma grande dose de ateno (e geralmente alguma depurao no
laboratrio). As breadboards so adequadas apenas para prototipagem, no para produo.
Figura A.12 Esquema do circuito com chips e identificao dos pinos
Placas de Circuito Impresso

Em vez de serem montados numa breadboard, os circuitos integrados podem ser soldados numa
placa de circuito impresso (PCB printed circuit board). A PCB formada por camadas alternadas de
cobre e isolante epoxi. O cobre removido para formar fios chamados traos. Os furos chamados de
vias so perfurados atravs da placa e revestidos com metal para os conectar entre as camadas. Os
PCB so normalmente concebidos com ferramentas (CAD) de desenho assistido por computador. O
leitor pode gravar e perfurar suas prprias placas em laboratrio, ou pode enviar o projeto da placa
para uma fbrica especializada para produo de baixo custo em massa. As fbricas tm tempos de
resposta de dias (ou semanas, para corridas de baixo custo de produo em massa) e geralmente
cobram algumas centenas de dlares em custos adicionais e alguns dlares para placa
moderadamente complexas construdas em grandes quantidades.
848
Figura A.13 Seco transversal de um PCB
Os traos do PCB so normalmente feitos de cobre, devido sua baixa resistncia. So incorporados
num material isolante, geralmente um plstico verde resistente ao fogo chamado FR4. O PCB tambm
normalmente tem uma camada de cobre de energia e terra, chamados de planos, entre camadas de
sinal. A Figura A.13 mostra uma seco transversal de uma PCB. As camadas de sinal esto na parte
superior e na parte inferior, e os planos de energia e de terra so incorporadas no centro da placa. Os
planos de alimentao e terra tm resistncia baixa, para que possam distribuir a energia de modo
estvel aos componentes na placa. Permitem tambm tonar previsvel e uniforme a capacitncia e a
indutncia dos traos.
A Figura A.14 mostra uma PCB para um computador Vintage de 1970 Apple II+. Na parte superior
h um microprocessador 6502. Abaixo esto seis chips de memria ROM de 16 Kb formando 12 KB de
ROM que contm o sistema operacional. Trs fileiras de oito chips de 16 Kb DRAM fornecer 48 KB de
RAM. direita h vrias linhas de lgica da srie 74xx para decodificao dos endereos de memria
e outras funes. As linhas entre chips so traos que interligam os chips. Os pontos nas extremidades
de alguns dos traos so vias cheias de metal.
849
Figura A.14 Placa do circuito do Apple II+
850
A.8 LINHAS DE TRASMISSO

Temos assumido que as ligaes so conexes equipotenciais que tm uma nica tenso ao longo de
todo o seu comprimento. Os sinais realmente se propagam ao longo dos condutores velocidade da luz
na forma de ondas eletromagnticas. Se estes so suficientemente curtos ou os sinais variam lentamente,
a suposio de equipotencial boa. Quando o condutor longo ou o sinal muito rpido, o tempo de
transmisso ao longo do condutor torna-se importante para determinar com preciso o atraso de
circuito. Devemos possuir modelos nos quais os condutores so linhas de transmisso, em que uma onda
de tenso e corrente se propaga velocidade da luz. Quando a onda atinge o fim da linha, pode haver
uma reflexo de volta ao longo da linha. A reflexo pode causar rudo e comportamentos estranhos a
menos que sejam tomadas medidas para os limitar. Assim, o projetista digital deve considerar o
comportamento da linha de transmisso para contabilizar com preciso os efeitos de atraso e de rudo
em condutores longos.
As ondas eletromagnticas viajam velocidade da luz num determinado meio, que rpida, mas no
instantnea. A velocidade da luz, , depende da permitividade, , e permeabilidade, , do meio: =
1 1
= .

A velocidade da luz no espao livre de = = 3 108 /. Os sinais viajam num PCB em cerca de
metade dessa velocidade, porque o isolador FR4 tem quatro vezes a permissividade do ar. Assim, os sinais
do PCB viajam a cerca de 1,5 108 /, ou 15 /. O tempo de atraso para um sinal para viajar ao
longo de uma linha de transmisso de comprimento l

= (A.4)
A impedncia caracterstica da linha de transmisso, Z0, a razo entre a tenso e a corrente de uma

onda que se desloca ao longo da linha: 0 = . No a resistncia do fio (uma boa linha de transmisso

num sistema digital tipicamente tem resistncia desprezvel). Z0 depende da indutncia e capacitncia da
linha (ver a Seco A.8.7) e tipicamente tem um valor de 50 a 75 .
851

0 = (A.4)
A Figura A.15 mostra o smbolo para uma linha de transmisso. O smbolo se assemelha a um cabo
coaxial com um condutor de sinal interno e um condutor aterrado exterior como aquele usado na
televiso por cabo.
Figura A.15 Representao de uma linha de transmisso
A chave para a compreenso do comportamento das linhas de transmisso est em visualizar a

propagao da onda de tenso ao longo da linha velocidade da luz. Quando a onda atinge o fim da
linha, pode ser absorvida ou refletida, dependendo da terminao ou carga no final. As reflexes
viajam de volta ao longo da linha, somando-se tenso j na linha. As terminaes so classificadas
como matched, open, short, ou mismatched. As Sees a seguir explorar como a onda se propaga ao
longo da linha e o que acontece com a onda quando atinge a terminao.
A.8.1 Terminao Matched
A Figura A.16 mostra uma linha de transmisso de comprimento l com uma terminao matched,
o que significa que a impedncia da carga, ZL, igual impedncia caracterstica, Z0. A linha de
transmisso tem uma impedncia caracterstica de 50 . Uma extremidade da linha est ligada a uma
fonte de tenso por meio de um interruptor que fecha no momento t = 0. A outra extremidade est
ligada carga matched de 50 . Esta seco analisa as tenses e as correntes nos pontos A, B, e C -
no incio da linha, a um tero do comprimento da linha, e no final da linha, respectivamente.
852
Figura A.16 Linha de transmisso com a terminao matched
A Figura A.17 mostra as tenses nos pontos A, B e C ao longo do tempo. Inicialmente, no h tenso
ou corrente na linha de transmisso, porque o interruptor est aberto. No tempo t = 0, o interruptor
fecha, e a fonte de tenso lana uma onda com a tenso V = VS ao longo da linha. Isto chamada a
onda incidente. Uma vez que a impedncia caracterstica Z0, a onda tem corrente I = VS / Z0. A tenso
atinge o incio da linha (ponto A), imediatamente, tal como mostrado na Figura A.17 (a). A onda se
propaga ao longo da linha velocidade da luz. No instante td/3, a onda atinge o ponto B. A tenso
neste ponto se eleva bruscamente de 0 a VS, tal como mostrado na Figura A.17 (b). No instante td, a
onda incidente atinge o ponto C no final da linha, a tenso aumenta tambm ai. Toda a corrente, I, flui
para o resistor, ZL, produzindo uma tenso atravs da resistncia de ZLI = ZL (VS / Z0) = VS porque ZL =
Z0. Esta tenso consistente com a onda que flui ao longo da linha de transmisso. Assim, a onda
absorvida pela impedncia de carga, e a linha de transmisso atinge o seu estado de equilbrio.
Em estado estacionrio, a linha de transmisso comporta-se como um fio de potencial ideal, pois
, afinal, apenas um fio. A tenso em todos os pontos ao longo da linha deve ser idntica. A Figura
A.18 mostra o modelo equivalente em estado estacionrio para o circuito da Figura A.6. A tenso VS
em todos os pontos ao longo do fio.
Exemplo A.2 LINHAS DE TRANSMISSO COM FONTE MATCHED E TERMINAO DE CARGA

A Figura A.19 mostra uma linha de transmisso com impedncias de fonte e de terminao matched
ZS e ZL. Represente a tenso nos ns A, B, e C em funo do tempo. Quando que o sistema atinge o Figura A.17 Formas de onda da
estado estacionrio, e qual o circuito equivalente no estado de equilbrio? Figura A.16 nos pontos A, B e C
Soluo: Quando a fonte de tenso tem uma impedncia ZS em srie com a linha de transmisso, parte
da queda de tenso ocorre atravs de ZS, e o restante propaga-se ao longo da linha de transmisso.
853
Em primeiro lugar, a linha de transmisso comporta-se como uma impedncia Z0, porque a carga na
extremidade da linha possivelmente no pode influenciar o comportamento da linha at que um
atraso velocidade de luz tenha ocorrido. Assim, pela equao do divisor de tenso, a tenso
incidente que flui pela linha
0
= ( )= (A.6)
0 + 2
Assim, no instante t = 0, uma onda de tenso, V = VS/2, enviada do ponto A pela linha. Mais
uma vez, o sinal atinge o ponto B no tempo td/3 e o ponto C em td, como mostrado na Figura A.20.
Toda a corrente absorvida pela impedncia de carga ZL, de modo que o circuito entra em estado
estacionrio em t = td. Em estado estacionrio, a linha inteira est a VS/2, assim como o circuito de
estado estacionrio equivalente na Figura A.21 permite prever.
Figura A.19 Linha de transmisso com match de impedncias de fonte e de carga

Figura A.20 Formas de onda da Figura A.8.2 Terminao Open
A.19 nos pontos A, B e C
Quando a impedncia de carga no igual a Z0, a terminao no pode absorver a totalidade da
corrente, e alguma da onda vai ser refletida. A Figura A.23 mostra uma linha de transmisso com
uma terminao de carga open. Nenhuma corrente pode fluir atravs de uma terminao open, de
modo que a corrente no ponto C deve ser sempre 0.
A tenso na linha inicialmente zero. Em t = 0, o interruptor fecha e uma onda de tenso, =
0
Figura A.21 Circuito equivalente da ( ) = 2, comea a propagar-se pela linha. Note-se que esta onda inicial a mesma que a do
0 +
Figura A.19 no regime estacionrio Exemplo A.2 e independente da terminao, porque a carga na extremidade da linha no pode
influenciar o comportamento no incio at pelo menos que 2td tenha decorrido. Esta onda atinge o
ponto B em td/3 e o ponto C em td como mostrado na Figura A.22.
854
Quando a onda incidente atinge o ponto C, no pode continuar em frente porque o condutor est
aberto. Deve em vez refletir de volta para a fonte. A onda refletida tambm tem tenso V = VS/2, pois
a terminao open reflete a onda inteira.
Figura A.23 Linha de transmisso com terminao open
A.8.3 Terminao Short

A Figura A.24 mostra uma linha de transmisso terminada com um curto-circuito terra. Assim, a
tenso no ponto C deve ser sempre 0.
Como nos exemplos anteriores, as tenses na linha so inicialmente 0. Quando o interruptor fecha,
uma onda de tenso, V = VS/2, comea a propagar-se pela linha (Figura A.25). Quando chega ao fim
da linha, deve refletir com polaridade oposta. A onda refletida, com tenso V = -VS/2, soma-se onda
incidente, assegurando que a tenso no ponto C permanece 0. A onda refletida atinge a fonte no
instante t = 2td e absorvida pela impedncia de fonte. Neste momento, o sistema atinge o regime
estacionrio, e a linha de transmisso equivalente a um condutor de equipotencial com tenso nula.
Figura A.22 Formas de onda da

Figura A.23 nos pontos A, B e C
Figura A.25
Figura A.24 Linha de transmisso com terminao short
855
A.8.4 Terminao Mismatched

A impedncia de terminao dita mismatched quando no for igual impedncia caracterstica
da linha. Em geral, quando uma onda incidente atinja uma terminao mismatched, parte da onda
absorvida e parte refletida. O coeficiente de reflexo kr indica a fraco da onda incidente Vi que
refletida: Vr = krVi.
A Seo A.8.8 deriva o coeficiente de reflexo usando a conservao das correntes. Isso mostra
que, quando uma onda incidente que flui ao longo de uma linha de transmisso de impedncia
caracterstica Z0 atinge uma impedncia de terminao ZT no final da linha, o coeficiente de reflexo

= +0 (A.7)
0
De notar alguns casos especiais. Se a terminao um circuito aberto (ZT = ), kr = 1, porque a

onda incidente refletida totalmente (assim a corrente para fora da extremidade da linha permanece
zero). Se a terminao um curto-circuito (ZT = 0), R = -1, porque a onda incidente refletida com a
fase invertida (de modo que a tenso na extremidade da linha permanece zero). Se a terminao
uma carga matched (ZT = Z0), kr = 0, porque a onda incidente completamente absorvida.
A Figura A.26 ilustra a reflexo numa linha de transmisso com uma terminao de carga
mismatched de 75 . ZT = ZL = 75 , e Z0 = 50 , ento kr = 1/5. Como nos exemplos anteriores, a
tenso na linha inicialmente 0. Quando o interruptor fechado, uma onda de tenso V = VS/2
propaga-se pela linha, atingindo o fim em t = td. Quando a onda incidente atinge a terminao no
final da linha, um quinto da onda refletida, e os restantes quatro quintos fluem para a impedncia
de carga. Assim, a onda refletida tem uma tenso de V = VS/2 1/5 = VS/10: A tenso total no ponto
C a soma da tenso de entrada e da refletida, VC = VS/2 + VS/10 = 3VS/5: Em t = 2td , a onda refletida
atinge o ponto A, onde absorvida pela terminao de 50 , ZS. A Figura A.27 representa
graficamente as correntes e tenses ao longo da linha. Mais uma vez, devemos notar que, em regime
estacionrio (neste caso no instante t > 2td), a linha de transmisso equivalente a um condutor de
Figura A.25 Formas de onda da
potencial, como mostrado na Figura A.28. No regime estacionrio, o sistema atua como um divisor
Figura A.24 nos pontos A, B e C
de tenso, assim
856
75 3
= = = ( ) = (75+50) = (A.8)
+ 5
Figura A.26 Linha de transmisso com terminao mismatched
Figura A.27 Formas de onda da Figura A.26 nos pontos A, B e C
Figura A.28 Circuito equivalente da Figura A.26 em regime estacionrio
As reflexes podem ocorrer em ambas as extremidades da linha de transmisso. A Figura A.29

mostra uma linha de transmisso com uma impedncia da fonte, ZS, de 450 e uma terminao open
na carga. Os coeficientes de reflexo na carga e fonte, krL e krS, so 1 e 4/5, respectivamente. Neste
caso, as ondas refletem de ambas as extremidades da linha de transmisso at que um regime
estacionrio seja atingido.
857
Figura A.29 Linha de transmisso com terminao de carga e fonte mismatched
O diagrama de bounce mostrado na Figura A.30 ajuda a visualizar as reflexes de ambas as

extremidades da linha de transmisso. O eixo horizontal representa a distncia ao longo da linha de
transmisso, e o eixo vertical representa o tempo, aumentando para baixo. Os dois lados do
diagrama de bounce representam as extremidades da fonte e de carga da linha de transmisso, os
pontos A e C. As ondas dos sinais de entrada e refletidos so desenhados como linhas diagonais
entre os pontos A e C. No instante t = 0, a impedncia da fonte e da linha de transmisso comporta-
se como um divisor de tenso, lanando uma onda de tenso VS/10 do ponto A para o ponto C. No
instante t = td, o sinal atinge o ponto C e totalmente refletido (krL = 1). No instante t = 2td, a onda
refletida de VS/10 atinge o ponto A e refletida com um coeficiente de reflexo, krS = 4/5, para
produzir uma onda de 2VS/25 que viaja para o ponto C, e assim por diante.
A tenso num determinado momento, em qualquer ponto da linha de transmisso a soma de
todos as ondas incidentes e refletidas. Assim, no instante t = 1.1td, a tenso no ponto C VS/10 +
VS/10 = VS/5: No instante t = 3.1td, a tenso no ponto C VS/10 + VS/10 + 2VS/25 + 2VS/25 = 9VS/25,
e assim por diante. A Figura A.31 traa as tenses no tempo. Com t a aproximar-se do infinito, as
tenses se aproximam do regime estacionrio com VA = VB = VC = VS.
Figura A.30 Diagrama de bounce para

a figura A.29
858
Figura A.31 Formas de onda da tenso e da corrente para a Figura A.29
A.8.5 Quando Devemos usar Modelos das Linhas de Transmisso

Os modelos de linhas de transmisso para os condutores so necessrios sempre que o atraso do
condutor, td, maior do que uma fraco (por exemplo, 20%) das taxas de transio (tempos de subida
ou descida) de um sinal. Se o atraso do condutor menor, tem um efeito desprezvel de atraso na
propagao do sinal, e as reflexes dissipam-se enquanto o sinal ainda est em transio. Se o atraso
do condutor maior, deve ser considerado, a fim de prever com preciso o atraso de propagao e a
forma de onda do sinal. Em particular, as reflexes podem distorcer a caracterstica digital de uma
forma de onda, resultando em operaes lgicas incorretas.
Lembre-se que os sinais viajam num PCB a cerca de 15 cm/ns. Para a lgica TTL, com taxas de
transio de 10 ns, os condutores devem ser modelados como linhas de transmisso somente se
possuem um comprimento superior a 30 cm (10ns 15 cm/ns 20%). As pistas nos PCB so geralmente
menores que 30 cm, por isso, a maioria das pistas pode ser modelada como um condutor equipotencial
ideal. Em contraste, muitos chips modernos tm taxas de transio de 2ns ou menos, de modo que
pistas com mais do que cerca de 6 cm (cerca de 2,5 polegadas) devem ser modeladas como linhas de
transmisso. Claramente, a utilizao de taxas de transio que so mais complicadas do que o
necessrio apenas provoca dificuldades ao projetista.
As breadboards no tm um plano de terra, de modo que os campos eletromagnticos de cada sinal
so no-uniformes e por isso difcil criar um modelo. Alm disso, os campos interagem com os sinais.
Isso pode causar reflexos estranhos e crosstalk entre os sinais. Assim, as breadboards no so fiveis
acima de alguns megahertz.
859
Em contraste, os PCB tm boas linhas de transmisso com impedncia caracterstica e velocidade

consistente ao longo de toda a linha. Se so terminadas com uma fonte ou impedncia de carga
matched com a impedncia da linha, as pistas nos PCB no sofrem reflexes.
A.8.6 Terminaes Adequadas das Linhas
H duas maneiras comuns para terminar adequadamente uma linha de transmisso, mostradas
na Figura A.32. Na terminao paralela, o driver tem uma baixa impedncia (ZS 0). Uma resistncia
de carga ZL com impedncia Z0 colocada em paralelo com a carga (entre a entrada da porta do
receptor e da terra). Quando o driver comuta de 0 para VDD, envia uma onda de tenso VDD pela
linha. A onda absorvida pela terminao de carga matched, e no h lugar a reflexes. Na
terminao srie, uma resistncia de fonte ZS colocada em srie com o condutor para aumentar
a impedncia da fonte para Z0. A carga tem uma alta impedncia (ZL ). Quando o driver comuta,
envia uma onda com VDD tenso/2 pela linha. A onda reflete na carga do circuito aberto e regressa,
levando a tenso na linha at VDD. A onda absorvida na terminao da fonte. Ambos os esquemas
so semelhantes na medida em que a tenso nos receptores comuta de 0 a VDD em t = td, tal como
seria de desejar. Eles diferem no consumo de energia e nas formas de onda que aparecem nas
outras posies ao longo da linha. A terminao paralela dissipa energia continuamente atravs da
resistncia de carga quando a linha est a uma tenso High. A terminao srie no dissipa energia
DC, porque a carga um circuito aberto. No entanto, nas linhas em terminao srie, os pontos
perto do meio da linha de transmisso, inicialmente esto sujeitos a uma tenso de VDD/2, at que
a reflexo volte. Se outras portas esto ligadas ao meio da linha, elas vo ver momentaneamente
um nvel lgico ilegal. Portanto, a terminao srie funciona melhor na comunicao ponto-a-ponto
com um nico driver e um nico receptor. A terminao paralela melhor para um barramento
com vrios receptores, porque os receptores no meio da linha nunca veem um nvel lgico ilegal.
860
Figura A.32 Modos de terminao (a) paralela e (b) srie
861
A.8.7 Derivao de Z0*

Z0 a relao entre a tenso e a corrente numa onda em propagao ao longo de uma linha de
transmisso. Esta Seo deriva Z0; que pressupe algum conhecimento prvios de anlise de circuitos
resistncia-indutor-condensador (RLC).
Imagine que uma tenso em degrau aplicada entrada de uma linha de transmisso semi-infinita
(de modo que no haja reflexes). A Figura A.33 (a) mostra a linha semi-infinita e um modelo de um
segmento da linha de comprimento dx. Os parmetros R, G, e C so os valores de resistncia, de
indutncia, e de capacitncia por unidade de comprimento. A Figura A.33 (b) mostra o modelo da linha
de transmisso com um componente resistivo, R. Isto chamado um modelo de linha de transmisso
com perdas, porque a energia dissipada, ou perdida, na resistncia do condutor. No entanto, esta
perda muitas vezes desprezvel, e podemos simplificar a anlise ignorando o componente resistivo e
tratar a linha de transmisso como uma linha de transmisso ideal, como mostrado na Figura A.33 (c).
A tenso e a corrente so funes do tempo e do espao ao longo da linha de transmisso, como
dado por Equaes A.8 e A.9.

(, ) = (, ) (A.8)

(, ) = (, ) (A.9)

Tomando a derivada no espao da Equao A.8 e a derivada temporal da Equao A.9 e substituindo
resulta na Equao A.10, a equao de onda.
2 2
(, ) = 2 (, ) (A.10)
2
Z0 a relao entre a tenso e a corrente na linha de transmisso, tal como ilustrado na Figura A.34
(a). Z0 deve ser independente do comprimento da linha, pois o comportamento da onda no pode
depender de coisas distncia. Uma vez que independente do comprimento, a impedncia deve
ainda ser igual a Z0 aps a adio de uma pequena quantidade de linha de transmisso, dx, como
mostrado na Figura A.34 (b).
862
Figura A.33 Modelo para linhas de transmisso: (a) cabo semi-infinito, (b) perdas, (c) ideal
Figura A.34 Modelo para a linha de transmisso: (a) linha completa e (b) comprimento adicional dx
Introduzindo as impedncias de um indutor e um condensador, podemos reescrever a relao da

Figura A.34 na forma de equao:
1
0 = + [0 || ()] (A.11)
Fazendo um rearranjo, obtemos:
02 () + 2 0 = 0 (A.12)
Tomando o limite quando x tende para 0, o ltimo termo desaparece e encontramos que

0 = (A.13)
A.8.8 Derivao do Coeficiente de Reflexo*

O coeficiente de reflexo kr derivado utilizando a conservao da corrente. A Figura A.35 mostra
uma linha de transmisso com impedncia caracterstica Z0 e impedncia de carga ZL. Imagine que uma
863
onda incidente de tenso Vi e corrente Ii. Quando a onda atinge a terminao, alguma corrente IL
flui atravs da impedncia de carga, provocando uma queda de tenso VL. O restante da corrente
reflete de volta na linha numa onda de tenso Vr e corrente de Ir. Z0 a relao entre a tenso e a
corrente da onda que se propaga ao longo da linha, de modo que Vi/Ii = Vr/Ir = Z0.
A tenso na linha a soma das ondas de tenso incidentes e refletidas. A corrente que flui no
sentido positivo na linha a diferena entre as correntes das ondas incidentes e refletidas.
= + (A.14)
= + (A.15)
Figura A.35 Linha de transmisso mostrando as tenses e correntes de entrada, refletida e carga
Usando a lei de Ohm e substituindo IL, Ii, e Ir na Equao A.15, obtemos

( + )
= (A.16)
0 0
Rearranjando, resolvemos em ordem ao coeficiente kr:

= +0 ) (A.16)
0
A.8.9 Colocado Tudo Junto

As linhas de transmisso modelam o facto de que os sinais precisam de tempo para se propagar
ao longo de condutores longos porque a velocidade da luz finita. Uma linha de transmisso ideal
tem indutncia L uniforme e capacitncia C por unidade de comprimento e resistncia zero. A linha
de transmisso caracterizada atravs da sua impedncia caracterstica Z0 e atraso td, que pode ser
derivada a partir da indutncia, da capacitncia, e do comprimento do cabo. A linha de transmisso
864
tem efeitos significativos de atraso e de rudo em sinais cujos tempos de subida/descida so inferiores
a cerca de 5td. Isto significa que, para sistemas com tempos de subida/descida de 2 ns, as pistas do
PCB com mais do que cerca de 6 cm devem ser analisadas como linhas de transmisso para perceber
com preciso o seu comportamento.
Um sistema digital consiste de uma porta que define o estado de um longo condutor ligado
entrada de um segundo porto pode ser modelado com uma linha de transmisso conforme
mostrado na Figura A.36. A fonte de tenso, a impedncia da fonte S , e o interruptor modelam a
primeira porta a comutar de 0-1 no instante 0. A porta de drive no pode fornecer corrente infinita;
esta modelada por ZS. ZS geralmente pequena para uma porta lgica, mas um projetista pode
optar por adicionar um resistor em srie com a porta para aumentar ZS e corresponder a impedncia
da linha. A entrada para a segunda porta modelada como ZL. Os circuitos CMOS geralmente tm
pouca corrente de entrada, de modo que ZL pode estar perto do infinito. O projetista tambm pode
optar por adicionar um resistor em paralelo com a segunda porta, entre a entrada da porta e da terra,
de modo que ZL corresponde impedncia da linha.
Figura A.36 Sistema digital modelado com linhas de transmisso
865
Quando a primeira porta comuta, uma onda de tenso aplicada na linha de transmisso. A
impedncia da fonte e a linha de transmisso formam um divisor de tenso, de modo que a tenso da
onda incidente
0
= ( ) (A.18)
0 +
No instante td, a onda atinge o fim da linha. Parte absorvida pela impedncia de carga, e uma parte
refletida. O coeficiente de reflexo R indica que poro se reflete: R = Vr/VI, onde Vr a tenso da onda
refletida e Vi a tenso da onda incidente.

= +0 (A.19)
0
A onda refletida adiciona-se tenso j existente na linha. Atinge a fonte no instante 2td, onde uma
parte absorvida e parte novamente refletida. As reflexes continuam para a frente e para trs, e a
tenso na linha, eventualmente, aproxima-se do valor que seria esperado se a linha fosse um condutor
equipotencial simples.
A.9 ECONOMIA
Embora o projeto digital seja to divertido que alguns de ns fazemo-lo gratuitamente, a maioria dos
projetistas e empresas pretendem ganhar dinheiro. Portanto, as consideraes econmicas so um fator
importante nas decises de projeto.
O custo de um sistema digital pode ser dividido em custos no recorrentes de engenharia (NRE) e as
despesas recorrentes. Os NRE representam o custo de projetar o sistema. Ele inclui os custos dos salrios
da equipa de projeto, computao e software, e os custos de produo da primeira unidade operacional.
O custo totalmente de um projetista nos Estados Unidos em 2012 (incluindo salrio, seguro de sade,
plano de aposentadoria, e um computador com ferramentas de design) cerca de US $ 200.000 por ano,
ento os custos do projeto podem ser significativos. Os custos recorrentes so o custo de cada unidade
adicional; Isto inclui componentes, fabricao, marketing, suporte tcnico e transporte.
866
O preo de venda deve abranger no s o custo do sistema, mas tambm outros custos, como
aluguel de escritrio, impostos e salrios do pessoal que no contribuem diretamente para o projecto
(como o zelador e o CEO). Depois de todas estas despesas, a empresa deve ainda fazer um lucro.
Exemplo A.3 O BEN PROCURA FAZER ALGUM DINHEIRO

Ben Bitdiddle projetou um circuito astuto para a contagem das gotas de chuva. Ele decide vender
o dispositivo e tentar fazer algum dinheiro, mas ele precisa de ajuda para decidir qual a
implementao a usar. Ele decide usar uma FPGA ou um ASIC. O kit de desenvolvimento para projetar
e testar a FPGA custa $1500. Cada FPGA custa $17. O ASIC custa $600.000 para uma mscara e $4 por
chip.
Independentemente de qual o chip escolhido a usar na implementao, Ben precisa montar o chip
numa placa de circuito impresso (PCB), que lhe custar $1,50 por placa. Ele acha que pode vender
1000 dispositivos por ms. Ben tem trabalhado com uma equipa de estudantes brilhantes, por isso
no custa nada para ele o projeto.
Se o preo de venda tem que ser duas vezes o custo (margem de lucro de 100%), e a vida til do
produto de 2 anos, qual a implementao a ser escolhida?
Soluo: Ben descobre o custo total para cada aplicao a 2 anos, como mostra a Tabela A.4. Mais de
2 anos, Ben planeja vender 24.000 dispositivos, e o custo total dado na Tabela A.4 para cada opo.
Se a vida til do produto de apenas dois anos, a opo da FPGA claramente superior. O custo por
unidade de $445.500 / 24.000 = $18,56, e o preo de venda de $37,13 por unidade para dar uma
margem de lucro de 100%. A opo do ASIC teria custado 732.000 / 24.000 = $30,50 e teria sido
vendida por $61 por unidade.
867
Tabela A.4 Custo FPGA vs ASIC
Exemplo A.4 BEN FICA GANANCIOSO

Depois de ver os anncios de marketing para o seu produto, Ben acha que pode vender ainda mais
chips por ms do que o inicialmente esperado. Se ele tivesse que escolher a opo ASIC, quantos
dispositivos por ms ele teria que vender para fazer a opo ASIC mais rentvel do que a opo FPGA?
Soluo: Ben resolve para o nmero mnimo de unidades, N, que ele precisaria vender em 2 anos:
$600,000 + (N $5,50) = $1500 +(N $18,50)
Resolvendo a equao obtemos N = 46 039 unidades, ou 1919 unidades por ms. Ele precisaria quase
o dobro das vendas mensais para beneficiar da soluo ASIC.
868
Exemplo A.5 BEN FICA MENOS GANANCIOSO

Ben percebe que os olhos ficaram maiores do que a barriga, e acha que no pode vender mais de
1000 dispositivos por ms. Mas pensa que a vida til do produto pode ser superior a 2 anos. Num
volume de vendas de 1000 dispositivos por ms, qual seria o tempo de vida do produto para fazer a
opo ASIC valer a pena?
Soluo: Se Ben vende mais de 46 039 unidades no total, a opo ASIC a melhor escolha. Ento,
Ben precisaria vender um volume de 1000 por ms durante pelo menos 47 meses (arredondando
para cima), que quase 4 anos. At ento, o produto susceptvel de ficar obsoleto.
Os chips so geralmente comprados de um distribuidor, em vez de diretamente do fabricante (a

menos que voc esteja precisando dezenas de milhares de unidades). A Digikey (www.digikey.com)
um dos principais distribuidores que vende uma grande variedade de produtos electrnicos. A
Jameco (www.jameco.com) e All Electronics (www.allelectronics.com) tm catlogos eclticos com
preos competitivos e bem adequado para amadores.
869
870
B Instrues MIPS
Este apndice sumariza as instrues MIPS utilizadas neste livro. As Tabela C.1 - Tabela C.3 definem
campos de opcode e funct para cada instruo, juntamente com uma breve descrio do que a
instruo faz. As seguintes notaes so usadas:
[reg]: Contedo do registro
imm: Campo do imediato de 16-bit
addr: Campo de endereo de 26-bit de instrues do tipo-J
SignImm: imediato de sinal estendido de 32-bit

= {{16{imm[15]}}, imm}
ZeroImm: imediato zero estendido de 32-bit

= {16'b0, imm}
Address: [rs] + SignImm
[Address]: Contedo do endereo de memria Address
BTA: Endereo de destino do salto
871
Apndice B Instrues MIPS
= PC + 4 + (SignImm << 2)
JTA: Endereo do salto

= {(PC + 4)[31:28], addr, 2'b0}
label: Texto indicando a localizao de um instruo
O BTA no simulador SPIM PC + (SignImm << 2) porque no tem atraso de salto. Assim, se o
leitor usar o assembler SPIM para criar cdigo de mquina para um processador MIPS verdadeiro,
deve diminuir de 1 o campo imediato de cada instruo salto para compensar.
872
Tabela B.1 Instrues organizadas por opcode
873
Tabela B.1 Instrues organizadas por opcode (Contnuao)
Tabela B.2 Instrues do tipo-R, organizadas pelo campo funct
874
Tabela B.2 Instrues do tipo-R, organizadas pelo campo funct (continuao)
Tabela B.3 Instrues do tipo-F (fop = 16/17)
875
876
C Programao em C
C.1 INTRODUO
O objetivo geral deste livro dar uma imagem de como os computadores funcionam em muitos nveis,
dos transstores dos quais eles so construdos, por todo o caminho at aos softwares que eles executam.
Os primeiros cinco Captulos deste livro trabalham em cima dos nveis mais baixos de abstrao, dos
transstores s portas para os projetos lgicos. O Captulos 6 a 8 saltaram para a arquitetura, e
trabalharam com a microarquitetura para conectar o hardware ao software. Este Apndice sobre
programao em C faz uma ligao lgica entre os Captulos 5 e 6 cobrindo a programao em C como o
nvel mais alto de abstrao neste texto. Ele motiva o material de arquitetura, e liga este livro
experincia em programao, que j pode ser familiar ao leitor. Este material colocado no Apndice
para que os leitores possam facilmente cobri-lo ou pula-lo, dependendo da sua experincia anterior.
Os programadores utilizam muitas linguagens diferentes para dizer ao computador o que fazer.
Fundamentalmente, o computador processa instrues em linguagem mquina consistindo de 1 e 0,
como explorado no Captulo 6. Mas, programar em linguagem mquina tedioso e lento, levando os
programadores a utilizar linguagens mais abstratas para obter mais eficientemente o que desejam. A
Tabela C.1 lista alguns exemplos de linguagens em vrios nveis de abstrao.
Uma das linguagens mais populares de programao de todos os tempos chamada C. Ela foi
desenvolvida por um grupo que inclua Dennis Ritchie e Brian Kernighan, da Bell Laboratories, entre 1969
e 1973, para reescrever o sistema operacional UNIX a partir de seu cdigo assembly original. Por muitas
medidas, C (incluindo uma famlia de linguagens relacionadas, como C++, C# e Objective C) a linguagem
existente mais largamente utilizada. Sua popularidade fixada por vrios fatores, incluindo:
Disponibilidade em uma tremenda variedade de plataformas, de supercomputadores a
microcontroladores embarcados.
877
Apndice C Programando em C
Relativa facilidade de uso, com uma gigantesca base de usurios.

Nvel moderado de abstrao, fornecendo uma produtividade maior que a linguagem
assembly, e ainda dando ao programador um bom entendimento de como o cdigo ir ser executado.
Adequabilidade para a gerao de programas de alto desempenho.
Capacidade de interagir diretamente com o hardware.
Tabela C.1 Linguagens em graus aproximadamente decrescente de abstrao
O C foi formalmente introduzido em 1978

pelo livro clssico de Brian Kernighan e
Dennis Ritchie, The C Programming Este Captulo dedicado programao em C por uma variedade de razes. Mais importante, C
Language. Em 1989, o American National
permite ao programador acessar diretamente endereos na memria, ilustrando a conexo entre
Standards Institute (ANSI) expandiu e
hardware e software enfatizada nesse livro. C uma linguagem prtica que todos os engenheiros e
padronizou a linguagem, que se tornou
conhecida como ANSI C, Standard C ou cientistas da computao deveriam saber. Ela utiliza muitos aspectos de implementao e projeto -
C89. Logo depois, em 1990, esse padro isto , desenvolvimento de software, programao de sistemas embarcados, e simulao tornando
foi adoptado pela International a proficincia em C uma habilidade vital e comercial.
Organization for Standardization (ISO) e
As seguintes Sees descrevem, como um todo, a sintaxe de um programa em C, discutindo cada
pelo Intenational Electrotechnical
parte do programa, incluindo o cabealho, declaraes de variveis e funes, tipos de dados, e
Commission (IEC). ISO/MEC atualizaram a
linguagem em 1999, para o que funes comumente utilizadas disponibilizadas em bibliotecas. A Seo 8.6 descreve aplicaes
chamada C99, que discutida nesse texto. importantes utilizando C para programar um microcontrolador 32.
878
Resumo
Programao de alto nvel: A programao de alto nvel til em muitos nveis de projeto, C a linguagem usada por sistemas
da anlise de escrita ou simulao de software at a programao de microcontroladores que onipresentes como Linux, Windows e iOS.
interagem com hardware. C uma linguagem poderosa devido ao
Acesso de baixo nvel: O cdigo em C poderoso porque, juntamente com construtores de seu acesso direto ao hardware. Quando
alto nvel, ele disponibiliza acesso a hardware de baixo nvel e memria. comparada a outras linguagens, como
Perl e Matab, C no possui muito suporte
C.2 BEM VINDO AO C embutido para operaes especializadas,
como manipulao de arquivos,
reconhecimento de padres,
Um programa em C um arquivo de texto que descreve as operaes a serem realizadas pelo
manipulao matricial, e interfaces
computador. O arquivo texto compilado, convertido num formato legvel pela mquina, e executado
grficas. Ela tambm carece de recursos
num computador. O Exemplo de Cdigo C.1 um simples programa em C que imprime a frase Hello para proteger o programador de erros
world! na consola, a tela do computador. Programas em C esto geralmente contidos num ou mais comuns, como escrever dados depois do
arquivos texto que terminam em .c. Um bom estilo de programao requer um nome de arquivo que fim de um array. Esse poder combinado a
indica o contedo do programa por exemplo, esse exemplo pode ser chamado de hello.c. essa carncia de proteo tem ajudado
hackers que exploram software de
Exemplo de Cdigo C.1 PROGRAMA C SIMPLES sistemas pobremente escritos, invadindo
// Write "Hello world!" to the console assim os sistemas de computadores.
#include <stdio.h>
int main(void){
printf("Hello world!\n");
}
Sada da Consola:
Hello world!
879
C.2.1 Dissecao de um Programa em C

Em geral, um programa em C organizado numa ou mais funes. Todos os programas devem
incluir a funcao main, onde o programa comea a ser executado. A maioria dos programas utiliza
outras funes, definidas em outro lugar do cdigo C e/ou numa biblioteca. As Sees gerais do
programa hello.c so o cabealho, a funo main, e o corpo.
Cabealho: #include <stdio.h>
O cabealho inclui as bibliotecas de funes necessrias para o programa. Neste caso, o programa
utiliza a funo printf, que parte da biblioteca I/O padro, stdio.h. Veja a Seo C.9 para mais
detalhes das bibliotecas C built-in.
Funo main: int main(void)
Todos os programas em C devem incluir exatamente uma funo main. A execuo do programa
Enquanto este captulo fornece uma
explicao fundamental de programao ocorre rodando-se o cdigo dentro de main, chamado corpo de main. A sintaxe de uma funo
em C, textos inteiros so escritos para descrita na Seo C.9. O corpo de uma funo contm uma sequncia de declaraes. Cada
descrever a fundo a linguagem C. Um nos declarao termina com um ponto e vrgula. O int denota que a funo main devolve, ou retorna,
nossos favoritos o texto clssico The C um resultado inteiro que indica que o programa rodou com sucesso.
Programming Language, de Brian
Corpo: printf(Hello world!\n);
Kernighan e Dennis Ritchie, os
desenvolvedores de C. Esse texto d uma O corpo dessa funo main contm uma declarao, uma chamada para a funo prinf, a qual
descrio concisa das nuts and Bolts de C. imprime a frase Hello world seguida de um caractere de quebra de linha indicado pela sequncia
Outro bom texto o A Book on C, de Al especial \n. Mais detalhes a respeito de funes I/O so descritos na Seo C.9.1.
Kelley e Ira Pohl.
C.2.2 Rodando um programa C
Os programas em C podem rodar em diferentes mquinas. Essa portabilidade outra vantagem
de C. O programa primeiramente compilado na mquina desejada utilizando-se um compilador C.
Existem verses ligeiramente diferentes do compilador C, incluindo o cc (C compiler), ou gcc (GNU C
compiler). Aqui mostramos como compilar e rodar um programa utilizando o gcc, que
disponibilizado gratuitamente para download. Ele roda diretamente em mquinas Linux, e
acessado atravs do ambiente Cygwin em mquinas Windows. Ele tambm disponibilizado para
880
muitos sistemas embarcados, como os microcontroladores 32 da Microchip. O processo geral

descrito abaixo para a criao de um arquivo C, compilao e execuo, o mesmo para qualquer
programa em C.
1. Crie o arquivo texto, por exemplo, hello.c.

2. Numa janela do terminal, mude o diretrio corrente para o que contm o arquivo hello.c,
e digite gcc hello.c no prompt de comando.
3. O compilador cria um arquivo executvel. Por padro, o executvel chamado a.out (ou
a.exe, em mquinas Windows).
4. No prompt de comando, digite ./a.out (ou ./a.exe no Windows) e pressione Enter.
5. Hello world! aparecer na tela.
Resumo
nomedoarquivo.c: Arquivos de programas em C so tipicamente nomeados com uma

extenso .c.
main: Cada programa C deve ter exatamente uma funo main.
#include: A maioria dos programas em C utilizam funes fornecidas por bibliotecas
built-in. Essas funes so utilizadas escrevendo-se #include <biblioteca.h> no
incio do arquivo C.
gcc nomedoarquivo.c: Arquivos C so convertidos num executvel utilizando-se um
compilador, como o GNU (gcc) ou o C compiler (cc).
Execuo: Aps a compilao, programas em C so executados digitando-se ./a.out (ou
./a.exe) na linha de comando.
C.3 COMPILAO
Um compilador um pedao de software que l um programa numa linguagem de alto nvel e o
converte num arquivo de cdigo mquina chamado de executvel. Livros inteiros so escritos sobre
881
compiladores, mas ns os descreveremos aqui brevemente. A operao geral de um compilador

(1) pr-processar o arquivo incluindo as bibliotecas referenciadas e expandindo as definies das
macros, (2) ignorar toda a informao desnecessria, como os comentrios, (3) traduzir o cdigo de
alto nvel em instrues simples nativas para o processador, que so representadas em binrio,
chamadas cdigo mquina, e (4) compilar todas as instrues num nico arquivo binrio que pode
ser lido e executado pelo computador. Cada linguagem mquina especfica para um dado
processador, ento o programa deve ser compilado especificamente para o sistema no qual ele ir
rodar. Por exemplo, a linguagem mquina MIPS coberta no Captulo 6 em detalhes.
C.3.1 Comentrios
Os programadores utilizam comentrios para descrever cdigo num alto nvel e esclarecer as
funes do cdigo. Qualquer pessoa que ler um cdigo sem comentrios pode atestar a sua
importncia. Programas em C utilizam dois tipos de comentrios: comentrios em linha simples
iniciam com // e terminam ao final da linha; comentrios de linhas mltiplas iniciam com /* e
terminam com */. Enquanto comentrios so crticos para a organizao e clareza do programa,
eles so ignorados pelo compilador.
// Esse um exemplo de um comentrio de uma linha.
/* Esse um exemplo
de um comentrio multi-linhas */
Um comentrio no topo de cada arquivo C til para descrever o autor do arquivo, datas de
criao e modificao, e propsitos. O comentrio abaixo pode ser includo no topo de um arquivo
hello.c.
// hello.c
// 1 de Junho 2012 Sarah_Harris@hmc.edu, David_Harris@hmc.edu
//
// Este programa imprime Hello world! na tela
882
C.3.2 #define Nmeros constantes em C so decimais por padro,

Constantes so nomeadas utilizando-se a diretiva #define, e ento utilizadas pelo nome durante mas tambm podem ser hexadecimais (prefixo
o programa. Estas constantes globalmente definidas tambm so chamadas macros. Por exemplo, "0x") ou octais (prefixo "0"). Constantes binrias
no so definidas em C99, mas so supoertadas por
suponha que voc escreve um programa que permite no mximo 5 perguntas do usurio, voc pode
alguns compiladores (prefixo "0b"). Por exemplo, as
usar #define para identificar aquele nmero. seguintes atribuies so equivalentes:
#define MAXPERGUNTAS 5 char x = 37;
O # indica que essa linha no programa ir ser tratada pelo pr-processador. Antes da compilao, char x = 0x25;
o pr-processador substitui cada ocorrncia do identificador MAXPERGUNTAS no programa por 5.
char x = 045;
Por conveno, as linhas #define esto localizadas no topo do arquivo, e os identificadores so
escritos todos em letras maiscula. Com a definio de constantes numa localizao e ento utilizar
o identificador no programa, o programa permanece consistente, e o valor facilmente modificado
Constantes globalmente definidas
ele precisa apenas ser modificado na linha #define ao invs de em cada linha de cdigo onde o
erradicaram os nmeros mgicos do
valor necessrio. programa. Um nmero mgico uma
constante que aparece num programa sem
O Exemplo de Cdigo C.2 mostra como utilizar a diretiva #define para converter polegadas em
um nome. A presena de nmeros mgicos
centmetros. As variveis inch e cm so declaradas como sendo float, para indicar que elas num programa frequentemente introduz bugs
representam nmeros em vrgula flutuante de preciso simples. Se o fator de converso (INCH2CM) complicados - por exemplo, quando um
fosse usado ao longo de um programa grande, t-lo declarado usando #define preveniria erros nmero modificado num local, mas no em
causados por digitao (por exemplo, digitar 2.53 ao invs de 2.54) e facilitaria a localizao de outro.
alguma mudana (por exemplo, se mais algarismos significativos fossem requeridos).
Exemplo de Cdigo C.2 USANDO #DEFINE PARA DECLARAR CONSTANTES

// Converte polegadas em centimetros
#include <stdio.h>
#define INCH2CM 2.54

int main(void) {
float inch = 5.5; // 5.5 polegadas
float cm;
883
cm = inch * INCH2CM;
printf("%f polegadas = %f cm\n", inch, cm);
}
Sada da Consola:
5.500000 polegadas = 13.970000 cm
C.3.3 #include
A modularidade encoraja a separar programas em arquivos separados e funes. Funes
comumente utilizadas podem ser agrupadas para facilitar a sua reutilizao. Declaraes de
variveis, valores definidos, e definies de funes localizadas num header file (cabealho) podem
ser utilizadas por outro arquivo, adicionando-se a diretiva do pr-processador #include. As
bibliotecas padro que disponibilizam funes comumente utilizadas so acessadas dessa forma. Por
exemplo, a linha seguinte requerida para a utilizao das funes definidas na biblioteca padro
de entrada/sada, como a funo printf.
#include <stdio.h>
O sufixo .h do arquivo include indica que ele um arquivo de cabealho. Enquanto diretivas
#include podem ser colocadas em qualquer lugar do arquivo antes das funes, variveis, ou
identificadores que so necessrios, elas so convencionalmente colocadas no topo de um arquivo
C.
Um arquivo de header criado pelo programador pode tambm ser includo utilizando-se aspas no
nome do arquivo ao invs de colchetes (< > ). Por exemplo, um arquivo de cabealho criado pelo
usurio chamado myfunctions.h poderia ser includo utilizando-se a seguinte linha:
#include myfunctions.h
Na hora de compilar, arquivos especificados entre colchetes so procurados nos diretrios do

sistema. Arquivos especificados entre aspas so procurados no mesmo diretrio local onde o arquivo
C encontrado. Se o arquivo de cabealho criado pelo usurio est localizado num diretrio
diferente, o caminho do arquivo relativo ao diretrio atual deve ser includo.
884
Resumo
Comentrios: C fornece comentrios de linha nica (//) e comentrios de vrias linha (/*
*/). Nomes de variveis so case sensitive, e
#define NOME val: A diretiva #define permite um identificador (NOME) ser podem ser de sua escolha. No entanto, o
utilizado ao longo do programa. Antes da compilao, todas as instncias de NOME so nome no pode ser qualquer uma das
substitudas por val. palavras reservadas em C (isto , int,
#include: #include permite que funes comuns sejam utilizadas no programa. Para while, etc), no podem comear com
bibliotecas built-in, inclua a seguinte linha no topo do cdigo: #include um nmero (isto , int 1x; no uma
declarao vlida), e no podem incluir
<biblioteca.h>. Para incluir um arquivo de cabealho definido pelo usurio, o nome
caracteres especiais, como \, *, ? ou
deve estar entre aspas, listando o caminho Comentrios: C disponibiliza comentrios de
- underscores (_) so permitidos.
linha simples (//) e comentrios multi-linhas relativo ao diretrio atual como necessrio,
isto , #include others/myFuncs.h.
C.4 VARIVEIS
As variveis nos programas em C possuem tipo, nome, valor, e localizao na memria. Uma
declarao de varivel define o tipo e o nome da varivel. Por exemplo, a seguinte declarao indica
que a varivel do tipo char (a qual um tipo de 1 byte), e o nome da varivel x. O compilador
decide em que lugar da memria deve-se colocar essa varivel de 1 byte.
char x;
O C considera a memria como um grupo de bytes consecutivos, onde a cada byte de memria
atribudo um nico nmero indicando a sua localizao, ou endereo, como mostrado na Figura C.1.
Uma varivel ocupa um ou mais bytes na memria, e o endereo das variveis de mltiplos bytes
Figura C.1 Viso de C da memria
indicado pelo nmero mais baixo do byte. O tipo de uma varivel indica se o byte interpretado
como inteiro, nmero de vrgula flutuante, ou outro tipo. O resto desta seo descreve os tipos
primitivos de dados em C, a declarao de variveis globais e locais, e a inicializao de variveis.
885
C.4.1 Tipos Primitivos de Dados

O C possui um nmero de tipos primitivos (ou built-in) de dados disponvel. Eles podem ser
amplamente caracterizados como inteiros, variveis de vrgula flutuante, ou caracteres. Um inteiro
representa um nmero em complemento-2, ou sem sinal, dentro de uma faixa finita. Uma varivel de
vrgula flutuante utiliza a representao IEEE de vrgula flutuante para descrever nmeros reais com
faixa e preciso finitas. Um caractere pode ser visto tanto quanto um valor ASCII ou um inteiro de 8-
bits. A Tabela C.2 lista o tamanho e a faixa de cada tipo primitivo. Os inteiros podem ser de 16-, 32- ou
64-bits. Eles utilizam o complemento-2, a menos que sejam qualificados como unsigned. O tamanho
de um tipo int dependente da mquina, e , geralmente, do tamanho da palavra nativa da mquina.
Por exemplo, num processador MIPS de 32-bits o tamanho de um int ou unsigned int de 32-
bits. Nmeros em vrgula flutuante podem ter 32- ou 64-bits em preciso simples ou dupla. Caracteres
possuem 8-bits.
Tabela C.2 Tipos e tamanhos primitivos de dados
886
A Tabela C.3 mostra a declarao de variveis de diferentes tipos. Como mostrado na Figura C.2,
x requer um byte de dados, y requer dois, e z requer quatro. O programa decide onde esses bytes
so armazenados na memria, mas cada tipo sempre requer a mesma quantidade de dados. Para
ilustrar, os endereos de x, y e z nesse exemplo so 1, 2 e 4. Nomes de variveis so case sensitive,
ento, por exemplo, a varivel x e a varivel X so duas variveis diferentes (mas seria bem confuso A natureza dependente do tipo de dado
int uma beno e uma maldio. Pelo
utilizar as duas no mesmo programa!).
lado bom, ela combina com o tamanho
natural de palavras do processador, ento
pode ser ajustada e manipulada
eficientemente. Por outro lado,
programas que utilizam int se
comportam de modo diferente em
computadores diferentes. Por exemplo,
um programa de um banco pode
armazenar nmero dos centavos na sua
conta como um int. Quando compilado
em um PC de 64 bits, ela ter plena faixa
de valores at para os mais ricos
empreendedores. Mas, se ela for portada
para um microcontrolador de 16 bits, ir
Figura C.2 Armazenamento de variveis na memria para o Exemplo de Cdigo C.3 ocorrer overflow para contas que
excedem $327,67, resultando em clientes
infelizes e endividados.
Exemplo de Cdigo C.3 EXEMPLOS DE TIPOS DE DADOS
// Exemplos de diversos tipos de data na sua representao binria
unsigned char x = 42; // x = 00101010
short y = 10; // y = 11111111 11110110
unsigned long z = 0; // z = 00000000 00000000 00000000 00000000
887
C.4.2 Variveis Globais e Locais

Variveis globais e locais diferem em onde elas so declaradas e onde elas esto visveis. Uma
O scope de uma varivel o contexto no varivel global declarada fora de todas as funes, tipicamente no topo de um programa, e pode
qual ela pode ser usada. Por exemplo,
ser acessada por todas as funes. Variveis globais devem ser utilizadas com moderao, pois elas
para uma varivel local, o seu scope a
violam o princpio da modularidade, fazendo com que grandes programas se tornem difceis de ler.
funo em que declarada. El est fora do
scope em qualquer outro lugar. No entanto, uma varivel acessada por muitas funes pode ser feita global.
Uma varivel local declarada dentro de uma funo, e pode ser utilizada apenas por aquela
funo. Portanto, duas funes podem ter variveis locais com os mesmos nomes sem que uma
interfira na outra. Variveis locais so declaradas no incio de uma funo. Elas deixam de existir
quando a funo termina e so recriadas quando a funo chamada novamente. Elas no retm
valores de uma invocao de uma funo para a prxima.
Os Exemplo de Cdigo C.4 e Exemplo de Cdigo C.5 comparam programas usando variveis globais
versus variveis locais. No Exemplo de Cdigo C.4, a varivel global max pode ser acessada por
qualquer funo. Usar uma varivel local, como mostrado no Exemplo de Cdigo C.5, o estilo
prefervel, pois ele preserva a interface bem definida da modularidade.
Exemplo de Cdigo C.4 VARIVEIS GLOBAIS

// Usa uma varivel global para encontrar e imprimir o valor mximo entre trs
nmeros
int max; // varivel global mantm o valor mximo
void findMax(int a, int b, int c) {

max = a;
if (b > max) {
if (c > b) max = c;
else max = b;
} else if (c > max) max = c;
}
888
void printMax(void) {
printf("The maximum number is: %d\n", max);
}
int main(void) {
findMax(4, 3, 7);
printMax();
}
Exemplo de Cdigo C.5 VARIVEIS LOCAIS

// Usar variveis locais para encontrar e imprimir o valor mximo entre trs
nmeros
int getMax(int a, int b, int c) {

int result = a; // varivel local mantm o valor mximo
if (b > result) {
if (c > b) result = c;
else result = b;
} else if (c > result) result = c;
return result;
}
void printMax(int m) {
printf("The maximum number is: %d\n", m);
}
int main(void) {
int max;
max = getMax(4, 3, 7);
printMax(max);
}
889
C.4.3 Inicializando Variveis

Uma varivel necessita ser inicializada atribuda a um valor antes de ser lida. Quando uma
varivel declarada, o nmero correto de bytes reservado para aquela varivel na memria. No
entanto, a memria naquelas localizaes retm qualquer valor que ela tinha na ltima vez que foi
utilizada, essencialmente uma varivel aleatria. Variveis globais e locais podem ser inicializadas
quando so declaradas ou dentro do corpo do programa. O Exemplo de Cdigo C.3 mostra variveis
inicializadas ao mesmo tempo em que so declaradas. O Exemplo de Cdigo C.4 mostra como
variveis so inicializadas antes de seu uso, mas aps a declarao. A varivel global max inicializada
pela funo getMax antes de ser lida pela funo printMax. Ler uma varivel no inicializada um
erro comum de programao, e pode ser complicado de se consertar.
Resumo
Variveis: Cada varivel definida por seu tipo de dado e localizao de memria. Uma
varivel declarada como tipodedado nome.
Tipos de dados: Um tipo de dado descreve um tamanho (nmero de bytes) e a representao
(interpretao dos bytes) de uma varivel. A Tabela C.2 lista os tipos de dados built-in em C.
Memria: O C visualiza a memria como uma lista de bytes. A memria armazena as variveis
e associa cada varivel com um endereo (nmero de byte).
Variveis Globais: Variveis globais so declaradas fora de todas as funes e podem ser
acessadas em qualquer lugar do programa.
Variveis Locais: Variveis locais so declaradas dentro de uma funo e podem ser acessadas
apenas naquela funo.
Inicializao de Varivel: Cada varivel deve ser inicializada antes de ser lida. A inicializao
pode acontecer tanto na declarao quanto depois.
C.5 OPERADORES
O tipo mais comum de declarao num programa em C uma expresso, tal como
y = a + 3;
890
Uma expresso envolvendo operadores (como + ou *) agindo sobre um ou mais operandos,

como variveis ou constantes. O C suporta os operadores mostrados na Tabela C.3, listados por
categoria e por ordem decrescente de precedncia. Por exemplo, operadores multiplicativos tm
precedncia sobre operadores aditivos. Dentro de uma mesma categoria, operadores so
computados na ordem em que aparecem no programa.
Tabela C.3 Operadores listados em precedncia decrescente
891
Tabela C.4 Operadores listados em precedncia decrescente (Continuao)
Operadores unrios, tambm chamados operadores mondicos, possuem um nico operando.

Operadores ternrios possuem trs operandos, e todos os outros tm dois. O operador ternrio
(do latim, ternarius, que consiste de trs) escolhe o segundo ou o terceiro operando, dependendo
se o primeiro valor TRUE ou FALSE, respectivamente. O Exemplo de Cdigo C.6 mostra como
computar y = max(a,b) utilizando o operador ternrio, juntamente com uma declarao
equivalente, mas mais detalhada.
892
A verdade, a verdade inteira, e nada mais

que a verdade
Exemplo de Cdigo C.6 (A) OPERADOR TERNRIO, E (B) DECLARAO IF/ELSE EQUIVALENTE
O C considera uma varivel ser TRUE, se
(a) y = (a > b) ? a : b; // parnteses no so necessrios, mas deixam o cdigo
// mais limpo. ela for diferente de zero e FALSE se ela
zero. Os operadores lgicos e ternrios,
bem como as instrues de controle de
(b) if (a > b) y = a;
else y = b; fluxo, if e while, dependem da verdade
de uma varivel. Os operadores
Atribuies simples usam o operador =. O cdigo C tambm permite atribuies compostas, isto relacionais e lgicos produzem um
, atribuies aps uma simples operao, como adio (+=) ou multiplicao (*=). Em atribuies resultado que 1 quando TRUE ou 0
compostas, a varivel do lado esquerdo tanto operada quanto atribuda ao resultado. O Exemplo quando FALSE.
de Cdigo C.7 mostra essas e outras operaes em C. Valores binrios nos comentrios so indicados
com o prefixo 0b.
Exemplo de Cdigo C.7 EXEMPLOS DE OPERADORES
893
C.6 CHAMADAS DE FUNO

Nada entre parnteses tambm indica Modularidade a chave para a boa programao. Um programa grande dividido em pequenas
argumentos de entrada. Ento, neste caso, partes chamadas funes que, similarmente aos mdulos de hardware, possuem entradas, sadas e
ns poderamos ter escrito: comportamento bem definidos. O Exemplo de Cdigo C.8 mostra a funo sum3. A declarao da
funo comea com o tipo de retorno, int, seguido pelo nome, sum3, e as entradas contidas entre
void printPrompt()
parnteses (int a, int b, int c). Chaves { } so utilizadas para limitar o corpo da
funo, que pode conter zero ou mais declaraes. A declarao return indica o valor que a funo
deve retornar funo chamadora. Isso pode ser visto como a sada da funo. Uma funo pode
retornar apenas um nico valor.
Com a ordenao cuidadosa de funes,
prottipos podem ser desnecessrios. No Exemplo de Cdigo C.8 FUNO SUM3
entanto, eles so inevitveis em certos casos,
tais como quando uma funo f1 chama f2 e // Retorna a soma de trs variveis de entrada
f2 chama f1. um bom estilo de int sum3(int a, int b, int c) {
programao colocar prottipos para todas as int result = a + b + c;
funes do programa perto do incio do return result;
arquivo C ou em um arquivo cabealho. }
Aps a seguinte chamada para a funo sum3, y mantm o valor 42.

int y = sum3(10, 15, 17);
Apesar de uma funo poder possuir entradas e sadas, nenhuma delas necessria. O Exemplo
de Cdigo C.9 mostra uma funo que no tem entradas nem sadas. A palavra chave void antes
do nome da funo indica que nada retornado. Um void entre parnteses indica que a funo
no possui argumentos de entrada.
Exemplo de Cdigo C.9 FUNO PRINTPROMPT QUE NO POSSUI NEM ENTRADAS NEM SADAS
// Imprime um prompt na consola
void printPrompt(void)
{
printf("Please enter a number from 1-3:\n");
}
894
Uma funo deve ser declarada no cdigo antes de ser chamada. Isso pode ser feito colocando-se
a funo chamada anteriormente no arquivo. Por essa razo, main frequentemente colocada ao Tal como os nomes de variveis, os nomes
fim do arquivo C, aps todas as funes que ela chama. Alternativamente, um prottipo de funo de funes so case sensitive, no podem
pode ser colocado no programa antes da funo ser definida. O prottipo de funo a primeira linha conter nenhuma palavra reservada, no
da funo, declarando o tipo de retorno, nome da funo e suas entradas. Por exemplo, o prottipo podem conter caracteres especiais
de funo para as funes do Exemplo de Cdigo C.8 e Exemplo de Cdigo C.9 so: (exceto underscore), e no podem iniciar
com um nmero. Tipicamente, nomes de
int sum3(int a, int b, intc);
funes incluem verbetes do que elas
void printPrompt(void); fazem.
O Exemplo de Cdigo C.10 mostra como prottipos de funes so usados. Apesar de as funes Seja consistente no modo com capitaliza
por si s estarem depois de main, os prottipos de funo no incio do arquivo permitem que elas suas funes e nome de variveis, para
sejam utilizadas em main. que voc no tenha que constantemente
procurar pela capitalizao correta. Dois
Exemplo de Cdigo C.10 PROTTIPOS DE FUNO estilos comuns so o camelCase, no qual a
letra inicial de cada palavra aps a
#include <stdio.h>
primeira capitalizada como as corcovas
de um camelo (por exemplo,
// prottipos de funo printPrompt), ou usar underscors
int sum3(int a, int b, int c);
void printPrompt(void);
entre as palavras (por exemplo,
print_prompt). Temos observado,
no cientificamente, que o uso de
int main(void)
underscore agrava a sndrome do tnel
{
int y = sum3(10, 15, 20); carpal (meu dedo mindinho d pontadas
printf("sum3 result: %d\n", y); s de pensar em underscore!) e,
printPrompt(); consequentemente, preferimos usar a
} camelCase. Mas a coisa mais importante
int sum3(int a, int b, int c) {
ser consistente no estilo e na organizao.
int result = a+b+c;
return result;
}
void printPrompt(void) {
printf("Please enter a number from 1-3:\n");
895
Sada da Consola:
sum3 result: 45
Please enter a number from 1-3:
A funo main sempre declarada como retornando um int, que transmite ao sistema
operacional a razo para o encerramento do programa. Um zero indica realizao normal, enquanto
um valor diferente de zero sinaliza uma condio de erro. Se main atinge o fim sem ter encontrado
uma declarao return, ela ir automaticamente retornar 0. A maioria dos sistemas operacionais
no informa automaticamente o usurio do valor retornado pelo programa.
C.7 DECLARAES DE CONTROLE DE FLUXO

A linguagem C fornece declaraes de controle de fluxo para laos condicionais e loops.
Condicionais executam uma declarao apenas se uma condio alcanada. Um loop executa
repetidamente uma declarao at que uma condio seja alcanada.
C.7.1 Declaraes Condicionais
Declaraes if, if/else, e switch/case so declaraes condicionais comumente
utilizadas em linguagens de alto nvel, incluindo C.
Declaraes if
Uma declarao if executa a declarao imediatamente a seguir quando a expresso entre

parnteses TRUE (diferente de zero). O formato geral :
if (expresso)
Declarao
896
O Exemplo de Cdigo C.11 mostra como utilizar uma declarao if em C. Quando a varivel
aintBroke igual a 1, a varivel dontFix colocada em 1. Um bloco de mltiplas declaraes
pode ser executado colocando-se chaves { } em volta das declaraes, como mostrado no Exemplo
de Cdigo C.12.
Exemplo de Cdigo C.11 DECLARAO IF

int dontFix = 0;
if (aintBroke = = 1)
dontFix = 1;
Exemplo de Cdigo C.12 DECLARAO IF COM UM BLOCO DE CDIGO

// Se amt >= $2, prompt user e dispense candy
if (amt >= 2) {
printf("Select candy.\n");
dispenseCandy = 1;
}
Declaraes if/else
Declaraes if/else executam uma de duas declaraes, dependendo de uma condio, como
mostrado abaixo. Quando a expresso na declarao TRUE, a declarao 1 executada. Caso
contrrio, a declarao 2 executada.
if (expresso)
Declaracao1
else
Declaracao2
897
O Exemplo de Cdigo C.6 (b) d um exemplo de uma declarao if/else em C. O cdigo define
max como sendo igual a, se a maior que b; caso contrrio, max = b.
Declaraes switch/case
Declaraes switch/case executam uma de muitas declaraes, dependendo das condies,

como mostrado na forma geral abaixo.
switch (varivel) {
case (expressao1): declaracao 1 break;
default: declaracao 4
Por exemplo, se a varivel igual expressao2, a execuo continua a partir da

declaracao2 at que a palavra-chave break seja atingida. Nesse ponto, o programa sai da
declarao switch/case. Se nenhuma condio atingida, default executada.
Se a palavra-chave break omitida, a execuo comea do ponto onde a condio TRUE, e

ento segue executando os cases remanescentes abaixo dela. Isso normalmente no o que voc
quer, e um erro comum entre programadores C iniciantes.
O Exemplo de Cdigo C.13 mostra uma declarao switch/case que, dependendo da varivel
option, determina a quantidade de dinheiro amt a ser desembolsada. Uma declarao
switch/case equivalente a uma serie de declaraes if/else aninhadas, como mostrado no
cdigo equivalente do Exemplo de Cdigo C.14.
Exemplo de Cdigo C.13 DECLARAO SWITCH/CASE

// Atribui amt dependendo do valor de option
switch (option) {
case 1: amt = 100; break;
898

default: printf("Error: unknown option.\n");
}
Exemplo de Cdigo C.14 DECLARAO if/else ANINHADA

// Atribui amt dependendo do valor de option
if (option == 1) amt = 100;

else if (option == 2) amt = 50;
else printf("Error: unknown option.\n");
C.7.2 Loops
while, do/while e for so construtores de loop comuns utilizados em muitas linguagens de
alto nvel, inclusive C. Esses loops executam uma declarao repetidamente, at que uma condio
seja satisfeita.
Loops while
Loops while repetidamente executam uma declarao at que uma condio seja no satisfeita,
como mostrado na forma geral abaixo:
while (condio)
declarao
O loop while no Exemplo de Cdigo C.15 computa o fatorial de 9 = 9 8 7 1. Note que

a condio verificada antes do incio da execuo de declarao. Neste exemplo, a declarao
uma declarao composta, ento as chaves so necessrias.
899
Exemplo de Cdigo C.15 LOOP WHILE

// Computa 9! (o fatorial de 9)
int i = 1, fact = 1;
// multiplica os nmeros de 1 a 9
while (i < 10) { // loops while checa a condio primeiro
fact *= i;
i++;
}
Loops do/while
Loops do/while so como os loops while, mas a condio verficada somente depois da
declarao ter sido executada uma vez. O formato geral mostrado abaixo. A condio seguida por
um ponto e vrgula.
do
Declarao
while (condio);
O loop do/while no Exemplo de Cdigo C.16 pede ao usurio para adivinhar um nmero. O
programa verifica a condio (se o nmero do usurio o nmero correto) apenas aps o corpo do
do/while ter sido executado uma vez. Esse construtor til quando, como neste caso, algo deve
ser feito (por exemplo, o palpite do usurio) antes da condio ser verificada.
Exemplo de Cdigo C.16 LOOP DO/WHILE

//Pede ao usurio para adivinhar um nmero e checa contra a resposta certa.
#define MAXGUESSES 3
#define CORRECTNUM 7
int guess, numGuesses = 0;
900
do {
printf("Adivinhe um nmero entre 0 e 9. Voc tem mais %d palpites.\n",
(MAXGUESSES-numGuesses));
scanf("%d", &guess); // l a entrada do usurio
numGuesses++;
} while ( (numGuesses < MAXGUESSES) & (guess != CORRECTNUM) );
// loop do checa a condio aps a primeira iterao
if (guess = = CORRECTNUM)
printf("Voc acertou a resposta!!\n");
Loops for
Loops for, assim como loops while e do/while, repetidamente executam uma declarao at
que uma condio no seja satisfeita. No entanto, os loops for adicionam o suporte a uma varivel
de loop, que tipicamente mantm o controle do nmero de execues do loop. A forma geral do loop
for :
for (inicializao; condio; operao do loop)
declarao
O cdigo de inicializao executado apenas uma vez, antes do loop for ser iniciado. Se a condio
no TRUE, o loop existe. A operao do loop executada ao fim de cada operao. O Exemplo de
Cdigo C.17 mostra o fatorial de 9 computado utilizando-se um loop for.
Exemplo de Cdigo C.17 LOOP FOR

// Computa 9!
int i; //varivel de loop
int fact = 1;
for(i=1; i<10; i++)
fact *= i;
901
Enquanto os loops while e do/while no Exemplo de Cdigo C.15 e .

incluem o cdigo para incremento e verificao da varivel de loop, i, e numGuesses,
respectivamente, o loop for incorpora essas declaraes no seu formato. Um loop for pode ser
expresso, de forma equivalente, mas menos conveniente, como:
inicializao;
while (condio) {
declarao
operao de loop;
Resumo
Declaraes de controle de fluxo: A linguagem C fornece declaraes de controle de fluxo
para declaraes condicionais e loops.
Declaraes condicionais: Declaraes condicionais executam uma declarao quando uma
condio verdadeira. C inclui as seguintes declaraes condicionais: if, if/else, e
switch/case.
Loops: Loops executam repetidamente uma declarao at que uma condio seja falsa. C
fornece while, do/while e loops for.
C.8 MAIS TIPOS DE DADOS

Alm de inteiros de vrios tamanhos e nmeros em vrgula flutuante, a linguagem C inclui outros
tipos especiais de dados, incluindo: ponteiros, arrays, strings e estruturas. Estes tipos de dados so
introduzidos nesta seo, juntamente com alocao dinmica de memria.
902
C.8.1 Ponteiros
Um ponteiro um endereo de uma varivel. O Exemplo de Cdigo C.18 mostra como utilizar
ponteiros. salary1 e salary2 so variveis que contm inteiros, e ptr uma varivel que pode
manter o endereo de um inteiro. O compilador ir atribuir localizaes arbitrarias na RAM para essas
variveis, dependendo do ambiente de execuo. Por uma questo de prtica, suponha que esse
programa compilado num sistema de 32-bits, com salary1 nos endereos 070-73, salary2
nos endereos 074-77, e ptr em 078-7. A Figura C.3 mostra a memria e seu contedo aps o
programa ser executado.
Numa declarao de varivel, o asterisco (*) antes do nome da varivel significa que ela um
ponteiro para o tipo declarado. Ao usar uma varivel do tipo ponteiro, do operador * dereferncia
um ponteiro, retornando o valor armazenado no endereo de memria indicado contido no ponteiro.
O operador & pronunciado endereo de, e ele produz o endereo de memria da varivel sendo
referenciada.
Figura C.3 Contedos de memria aps o Exemplo de Cdigo C.18 mostrado (a) como valor e (b)
por byte usando memria little endian
903
Exemplo de Cdigo C.18 PONTEIROS

Dereferenciar um ponteiro para uma // Exemplo de manipulao de ponteiros
localizao de memria no existente ou para int salary1, salary2; // nmeros de 32 bits
um endereo fora da faixa acessvel pelo int *ptr; // ponteiro especificando o endereo de uma varivel
programa ir, usualmente, fazer com que o
programa trave. Essa falha frequentemente
salary1 = 67500; // salary1 = $67,500 = 0x000107AC
chamada de falha de segmentao.
ptr = &salary1; // ptr = 0x0070, endereo de salary1
salary2 = *ptr + 1000; /* dereferencia ptr para dar o contedo do endereo 70
= $67.500,
ento adiciona $1.000 e define salary2 como $68.500
*/
Ponteiros so particularmente teis quando uma funo precisa modificar uma varivel, ao invs
de simplesmente retornar um valor. Devido s funes no poderem modificar suas entradas
diretamente, uma funo pode fazer da entrada um ponteiro para a varivel. Isso denominado
fazer a passagem de uma varivel de entrada por referncia ao invs de por valor, como mostrado
nos primeiros exemplos. O Exemplo de Cdigo C.19 d um exemplo de como fazer a passagem de x
por referncia, de modo que quadruple possa modificar a varivel diretamente.
Exemplo de Cdigo C.19 FAZENDO A PASSAGEM DE UMA VARIVEL DE ENTRADA POR REFERNCIA
// Quadruplica o valor apontado por a
#include <stdio.h>
void quadruple(int *a)

{
*a = *a * 4;
}
904
int main(void)
{
int x = 5;
printf("x antes: %d\n", x);
quadruple(&x);
printf("x depois: %d\n", x);
return 0;
}
Consola da Output:
x antes: 5
x depois: 20
Um ponteiro para o endereo 0 chamado ponteiro null e indica que o ponteiro no est
verdadeiramente apontando para algum dado significativo. Ele escrito como NULL num programa.
C.8.2 Arrays
Um array um grupo de variveis similares armazenadas em endereos consecutivos na
memria. Os elementos so numerados de 0 a 1, onde o tamanho do array. O Exemplo de
Cdigo C.20 declara uma varivel do tipo array chamada scores, que mantm as notas dos exames
finais para trs estudantes. O espao de memria reservado para trs longs, isto , 3 4 = 12
bytes. Suponha que o array scores comeca no endereo 040. O endereo do primeiro
(scores[0]) 040, o segundo elemento 044, e o terceiro elemento 048, como mostrado
na Figura C.4. Em C, o array varivel, nesse caso scores, um ponteiro para o primeiro elemento.
responsabilidade do programador no acessar os elementos alm do fim do array. O C no possui
verificao de limite interno, ento um programa que escreve alm do fim de um array ser
compilado normalmente, mas poder passar sobre outras partes da memria quando for executado.
905
Exemplo de Cdigo C.20 DECLARAO DE ARRAY

long scores[3]; // array de trs nmeros de 4 bytes
Os elementos de um array podem ser inicializados tanto em uma declarao utilizando chaves {
}, como mostrado o Exemplo de Cdigo C.21, ou individualmente no corpo do cdigo, como
mostrado no Exemplo de Cdigo C.22. Cada elemento de um array acessado utilizando-se
colchetes [ ]. O contedo da memria contendo o array mostrado na Figura C.4. A inicializao
de um array utilizando-se chaves { } pode apenas ser realizada na declarao, e no depois. Os
loops for so comumente usados para atribuir e ler dados em arrays, como mostrado no Exemplo
de Cdigo C.23.
Exemplo de Cdigo C.21 INICIALIZAO DE ARRAY NA DECLARAO UTILIZANDO { }

long scores[3]={93, 81, 97}; // scores[0]=93; scores[1]=81; scores[2]=97;
Figura C.4 array scores armazenado na memria
906
Exemplo de Cdigo C.22 INICIALIZAO DE ARRAYS USANDO ATRIBUIES

long scores[3];
scores[0] = 93;
scores[1] = 81;
scores[2] = 97;
Exemplo de Cdigo C.23 INICIALIZAO DE ARRAY UTILIZANDO UM LOOP FOR

// Usurio entra com 3 notas de estudantes num array
long scores[3];
int i, entered;
printf("Por favor, informe as 3 notas dos estudantes.\n");
for (i=0; i<3; i++) {
printf("Informe uma nota e digite enter.\n");
scanf("%d", &entered);
scores[i] = entered;
}
printf("Notas: %d %d %d\n", scores[0], scores[1], scores[2]);
Quando um array declarado, o comprimento deve ser constante, de modo que o compilador
possa alocar a quantidade apropriada de memria. No entanto, quando o array passado para a
funo como um argumento de entrada, o comprimento no precisa ser definido, pois a funo
apenas precisa saber o endereo no incio do array. O Exemplo de Cdigo C.24 mostra como um array
passado para uma funo. O argumento de entrada arr simplesmente o endereo do primeiro
elemento do array. Frequentemente, o nmero de elementos num array tambm passado como
um argumento de entrada. Numa funo, um argumento de entrada do tipo int[] indica que est
num array de inteiros. Arrays de qualquer tipo podem ser passados para uma funo.
Exemplo de Cdigo C.24 PASSANDO UM ARRAY COMO UM ARGUMENTO DE ENTRADA

// Inicializa um array de 5 elementos, computa a media e imprime o resultado.
907
#include <stdio.h>
// Retorna o valor mdio de um array (arr) de comprimento len
float getMean(int arr[], int len) {

int i;
float mean, total = 0;
for (i=0; i < len; i++)
total += arr[i];
mean = total / len;
return mean;
}
int main(void) {
int data[4] = {78, 14, 99, 27};
float avg;
avg = getMean(data, 4);

printf("O valor mdio : %f.\n", avg);
}
Consola da Output:
O valor mdio : 54.500000.
Um argumento de array equivalente a um ponteiro no incio do array. Ento, getMean poderia

tambm ser declarada como:
float getMean(int *arr, int len);
Apesar de funcionalmente equivalente, datatype[] o mtodo preferido para passar arrays

como argumentos de entrada, pois mais claro indicar que o argumento um array.
Uma funo limitada a uma nica sada, isto , uma varivel de retorno. No entanto, recebendo
um array como argumento de entrada, uma funo pode, essencialmente, gerar na sada mais do
que um nico valor, atravs da mudana do array em si. O Exemplo de Cdigo C.25 ordena um array
do menor ndice para o maior, e deixa o resultado no mesmo array. Os trs prottipos de funo
abaixo so equivalentes. O comprimento de um array em uma declarao de funo ignorado.
908
void sort(int *vals, int len);

void sort(int vals[], int len);
void sort(int vals[100], int len);
Exemplo de Cdigo C.25 PASSANDO UM ARRAY E SEU COMPRIMENTO COMO ENTRADA

// Ordena os elementos de um array vals de comprimento len do menor para o maior
void sort(int vals[], int len)
{
int i, j, temp;
for (i=0; i<len; i++) {

for (j=i+1; j<len; j++) {
if (vals[i] > vals[j]) {
temp = vals[i];
vals[i] = vals[j];
vals[j] = temp;
}
}
}
}
Os arrays podem ter mltiplas dimenses. O Exemplo de Cdigo C.26 utiliza um array bidimensional
para armazenar as notas de um conjunto de oito problemas para dez estudantes. Lembre-se que a
inicializao de valores de arrays utilizando-se { } permitida apenas na declarao.
Exemplo de Cdigo C.26 INICIALIZAO DE ARRAY BIDIMENSIONAL

// Inicializa um array 2-D na declarao
int grades[10][8] = { {100, 107, 99, 101, 100, 104, 109, 117},
{103, 101, 94, 101, 102, 106, 105, 110},
{101, 102, 92, 101, 100, 107, 109, 110},
{114, 106, 95, 101, 100, 102, 102, 100},
{98, 105, 97, 101, 103, 104, 109, 109},
{105, 103, 99, 101, 105, 104, 101, 105},
{103, 101, 100, 101, 108, 105, 109, 100},
909
{100, 102, 102, 101, 102, 101, 105, 102},

{102, 106, 110, 101, 100, 102, 120, 103},
{99, 107, 98, 101, 109, 104, 110, 108} };
O Exemplo de Cdigo C.27 mostra algumas funes que operam no array 2-D grades do Exemplo
de Cdigo C.26. Os Arrays multi-dimenso utilizados como argumentos de entrada para uma funo
devem definir todos menos a primeira dimenso. Ento, os seguintes prottipos de funo so
aceitveis.
void print2dArray(int arr[10][8]);
void print2dArray(int arr[][8]);~
Exemplo de Cdigo C.27 OPERANDO COM ARRAYS MULTI-DIMENSIONAIS

#include <stdio.h>
// Imprime o conteudo de um array 10x8
void print2dArray(int arr[10][8])

{
int i, j;
for (i=0; i<10; i++) { // para cada um dos 10 estudantes

printf("Row %d\n", i);
for (j=0; j<8; j++) {
printf("%d ", arr[i][j]); // imprime as notas para os 8 conjuntos de
problemas
}
printf("\n");
}
}
// Calcula a pontuao mdia de um array 10x8

float getMean(int arr[10][8])
{
int i, j;
float mean, total = 0;
910
// obtem a media do array 2D

for (i=0; i<10; i++) {
for (j=0; j<8; j++) {

total += arr[i][j]; // soma valores dos arrays
}
}
mean = total/(10*8);
printf("Mean is: %f\n", mean);
return mean; O termo "carriage return" provm de

} mquinas de escrever que exigiam o
transporte, a engenhoca que segura o
Note que devido ao array ser representado por um ponteiro no elemento inicial, a linguagem C papel, para o mover para a direita, a fim
no pode copiar ou comparar arrays utilizando operadores = ou ==. Ao invs disso, voc deve utilizar de permitir a digitao comear no lado
um loop para copiar ou comparar cada elemento, um a cada vez. esquerdo da pgina. Uma alavanca de
retorno de carro, mostrado esquerda na
C.8.3 Caracteres figura abaixo, pressionada para
Um caractere (char) uma varivel de 8-bits. Ela pode ser vista como um nmero em movimentar para a direita e avanar o
complemento-2 entre 128 e 127 ou como um cdigo ASCII para uma letra, dgito ou smbolo. papel por uma linha, chamado de avano
Caracteres ASCII podem ser especificados como um valor numrico (em decimal, hexadecimal, etc), de linha (line feed).
ou como um caractere imprimvel entre aspas simples. Por exemplo, a letra A possui o cdigo ASCII
041, B=042, etc. Ento, + 3 044 ou . A Tabela 6.2 lista as codificaes de caracteres
ASCII, e a Tabela C.4 lista caracteres usados para indicar caracteres especiais ou de formatao. Os
cdigos de formatao incluem o carriage return (\r), newline (\n), tab horizontal (\t), e o fim de
uma string (\0). \r mostrado por exaustividade, mas raramente utilizado em programas em C.
O \r retorna a carriage (localizao de digitao) para o incio (esquerda) da linha, mas qualquer
texto que estava ali sobrescrito. \n, por sua vez, move a localizao da digitao para o incio de Uma mquina de escrever Remington
uma nova linha. O caractere NULL (\0) indica o fim de uma string de texto e discutido mais adiante electric utilizada por Winston Churchill.
na Seo C.8.4
(http://cwr.iwm.org.uk/server/show/con
C.8.4 Strings MediaFile.71979)
Uma string um array de caracteres utilizada para armazenar um pedao de texto de um
comprimento limitado, mas varivel. Cada caractere um byte representando um cdigo ASCII para
911
Strings em C so chamadas null aquela letra, nmero ou smbolo. O comprimento do array determina o comprimento mximo da
terminated ou zero terminated, pois o string, mas o verdadeiro comprimento da string pode ser menor. Em C, o comprimento de uma string
comprimento determinado pela procura determinado procurando-se a terminao null (valor ASCII 000) no final da string.
de um zero ao final. Em contraste,
linguagens como Pascal usam o primeiro O Exemplo de Cdigo C.28 mostra a declarao de um array de caracteres de 10 elementos,
byte para especificar o comprimento da chamado greeting, que mantm a string Hello!. Para concretizar, suponha que greeting
string, at um nmero mximo de 255 inicia no endereo de memria 050. A Figura C.5 mostra o contedo de memria de 050 at 059
caracteres. Esse byte chamado de byte mantendo a string Hello!. Note que a string utiliza apenas os primeiros sete elementos do array,
de prefixo e tais strings so chamadas P- mesmo se dez elementos forem alocados na memria.
strings. Uma vantagem das strings null
terminated a de que o comprimento Exemplo de Cdigo C.28 DECLARAO DE STRING
pode ser arbitrariamente grande. Uma
char greeting[10] = "Hello!";
vantagem das P-strings que o
comprimento pode ser determinado O Exemplo de Cdigo C.29 mostra uma declarao alternativa da string greeting. O ponteiro
imediatamente, sem a necessidade da
greeting mantm o endereo do primeiro elemento de um array de sete elementos composto de
inspeo de todos os caracteres da string.
cada um dos caracteres em Hello!, seguido pela terminao null. O cdigo tambm demonstra
como imprimir uma string utilizando-se o formato de cdigo %s.
Exemplo de Cdigo C.29 DECLARAAO ALTERNATIVA DE STRING

char *greeting = "Hello!";
printf("greeting: %s", greeting);
Sada da Consola:
greeting: Hello
Ao contrrio das variveis primitivas, uma string no pode ser definida igual a outra string
utilizando o operador de igualdade, =. Cada elemento do array de caracteres deve ser
individualmente copiado da string fonte para a string alvo. Isso verdadeiro para qualquer array. O
Exemplo de Cdigo C.30 copia uma strinf, src, para outra, dst. Os tamanhos dos arrays no so
necessrios, pois o fim da string src indicado pela terminao null. No entanto, dst deve ser
912
grande o suficiente, de modo que o leitor no esbarre em outro dado. Strcpy e outras funes de
manipulao de strings esto disponveis nas bibliotecas built-in de C (veja Seo C.9.4).
Exemplo de Cdigo C.30 COPIANDO: STRINGS

// Copia a string fonte, src, para a string destino, dst
void strcpy(char *dst, char *src)
{
int i = 0;
do {
dst[i] = src[i]; // copia caracteres um byte por vez
} while (src[i++]); // at o character null ser encontrado
}
Figura C.5 String Hello! armazenada na memria
913
C.8.5 Estruturas
Em C as estruturas so utilizadas para armazenar uma coleo de dados de vrios tipos. A forma
geral de uma declarao de estrutura
struct name {
type1 element1;
type2 element2;

};
onde struct uma palavra chave indicando que ela uma estrutura, name o nome da
estrutura, e element1 e element2 so membros da estrutura. Uma estrutura pode ter
qualquer nmero de membros. O Exemplo de Cdigo C.31 mostra como utilizar uma estrutura
para armazenar informaes de contato. O programa ento declara uma varivel c1 do tipo
struct contact.
Exemplo de Cdigo C.31 DECLARAO DE ESTRUTURA
struct contact {
char name[30];
int phone;
float height; // em metros
};
struct contact c1;
strcpy(c1.name, "Ben Bitdiddle");
c1.phone = 7226993;
c1.height = 1.82;
Da mesma forma que em que tipos built-in em C, o leitor pode criar arrays de estruturas e
ponteiros para estruturas. O Exemplo de Cdigo C.32 cria um array de contatos.
Exemplo de Cdigo C.32 ARRAY DE ESTRUTURAS
914
struct contact classlist[200];

classlist[0].phone = 9642025;
comum utilizar ponteiros para estruturas. A linguagem C fornece o operador member access ->
para dereferenciar um ponteiro para uma estrutura e acessar um membro da estrutura. O Exemplo
de Cdigo C.33 mostra um exemplo de declarao de um ponteiro para uma struct contact,
atribuindo-o para apontar o 42 elemento de classlist, do Exemplo de Cdigo C.32, e usando o
operador access member para definir um valor naquele elemento.
Exemplo de Cdigo C.33 ACESSANDO MEMBROS DE ESTRUTURAS UTILIZANDO PONTEIROS E ->

struct contact *cptr;
cptr = &classlist[42];
cptr->height = 1.9; // equivalente a: (*cptr).height = 1.9;
Estruturas podem ser passadas como entradas ou sadas de funes, por valor ou por referncia.
Passar por valor requer que o compilador copie a estrutura inteira para a memria para a funo a
acessar. Para uma estrutura grande, isso requer uma grande quantidade de memria e tempo.
Passando por referncia envolve passar um ponteiro para a estrutura, o que mais eficiente. A
funo pode tambm modificar a estrutura sendo apontada, ao invs de ter que retornar outra
estrutura. O Exemplo de Cdigo C.34 mostra duas verses para a funo stretch, que faz o contato
2 mais alto. stretchByReference evita a cpia da grande estrutura duas vezes.
Exemplo de Cdigo C.34 PASSANDO ESTRUTURAS POR NOME OU POR VALOR

struct contact stretchByValue(struct contact c)
{
c.height += 0.02;
return c;
}
void stretchByReference(struct contact *cptr)

{
915
cptr->height += 0.02;
}
int main(void)
{
struct contact George;
George.height = 1.4; // poor fellow has been stooped over
George = stretchByValue(George); // stretch for the stars
stretchByReference(&George); // and stretch some more
C.8.6 typedef*
A linguagem C tambm permite definir os seus prprios nomes para tipos de dados, utilizando a
declarao typedef. Por exemplo, escrever struct contact se torna tedioso quando ela
frequentemente usada, ento ns podemos definir um novo tipo, nomeado contact, e us-lo como
mostrado no Exemplo de Cdigo C.35.
Exemplo de Cdigo C.35 CRIANDO UM TIPO CUSTOMIZADO UTILIZANDO TYPEDEF

typedef struct contact {
char name[30];
int phone;
float height; // em metros
} contact; // define contact como um atalho para "struct contact"
contact c1; // agora ns podemos declarar a varivel como um tipo contact
typedef pode ser usada para criar um novo tipo, ocupando a mesma quantidade de memria
do que o tipo primitivo. O Exemplo de Cdigo C.36 define byte e bool como tipos de 8-bits. O tipo
byte pode deixar claro que o propsito de pos ser um nmero de 8-bits ao invs de um caractere
ASCII. O tipo bool indica que o nmero de 8-bits est representando TRUE ou FALSE. Estes tipos
fazem um programa mais fcil de ler do que se algum simplesmente utilizasse char em todo lugar.
916
Exemplo de Cdigo C.36 TYPEDEF BYTE E BOOL
typedef unsigned char byte;

typedef char bool;
#define TRUE 1
#define FALSE 0
byte pos = 0x45;

bool loveC = TRUE;
O Exemplo de Cdigo C.37 ilustra a definio de um vetor (vector) de trs elementos e uma
matriz (matrix) 3 3 utilizando arrays.
Exemplo de Cdigo C.37 TYPEDEF VECTOR E MATRIX
typedef double vector[3];

typedef double matrix[3][3];
vector a = {4.5, 2.3, 7.0};

matrix b = {{3.3, 4.7, 9.2}, {2.5, 4, 9}, {3.1, 99.2, 88}};
C.8.7 Alocao Dinmica de Memria*

Em todos os exemplos at aqui, as variveis tm sido declaradas estaticamente, isto , o seu
tamanho conhecido na hora da compilao. Isso pode ser problemtico para arrays e strings de
tamanhos variveis, pois o array deve ser declarado grande o suficiente para acomodar o maior
tamanho que o programa ir ver. Um modo alternativo alocar dinamicamente a memria durante a
execuo, quando o tamanho atual conhecido.
A funo malloc, da stdlib.h, aloca um bloco de memria de um tamanho especificado e

retorna um ponteiro para ela. Se no existe memria suficiente disponvel, um ponteiro NULL
retornado, nesse caso. Por exemplo, o seguinte cdigo aloca 10 shorts (10 2 = 20 bytes). O
operador sizeof retorna o tamanho de um tipo ou varivel em bytes.
917
// alocao dinmica de 20 bytes de memria

short *data = malloc(10*sizeof(short));
O Exemplo de Cdigo C.38 ilustra a alocao e libertao dinmica. O programa aceita um nmero
varivel de entradas, armazena-as num array dinamicamente alocado, e computa sua mdia. A
quantidade de memria necessria depende do nmero de elementos no array e do tamanho de cada
elemento. Por exemplo, se um int uma varivel de 4 bytes e 10 elementos so necessrios, 40
bytes so dinamicamente alocados. A funo free liberta a memria, de modo que ela possa ser
utilizada depois para outros propsitos. A falha na libertao dinmica de dados alocados chamado
vazamento de memria e deve ser evitado.
Exemplo de Cdigo C.38 ALOCAO E DESALOCAO DINMICA DE MEMRIA

// Dinamicamente alocar e desalocar um array usando malloc and free
#include <stdlib.h>
// Inserir funo getMean do Exemplo C.24.
int main(void) {
int len, i;
int *nums;
printf("Quantos nmeros voc deseja inserir? ");
scanf("%d", &len);
nums = malloc(len*sizeof(int));
if (nums == NULL) printf("ERROR: sem memria.\n");
else {
for (i=0; i<len; i++) {
printf("Entre com o nmero: ");
scanf("%d", &nums[i]);
}
printf("A mdia %f\n", getMean(nums, len));
}
free(nums);
918
C.8.8 Listas Ligadas

Uma lista ligada ou lista encadeada uma estrutura comum de dados utilizada para armazenar um
nmero variado de elementos. Cada elemento na lista uma estrutura contendo um ou mais campos
de dados e ligados ao prximo elemento. O primeiro elemento na lista chamado cabea. Listas
ligadas ilustram muitos conceitos de estruturas, ponteiros, e alocao dinmica de memria.
O Exemplo de Cdigo C.39 descreve uma lista ligada para armazenar contas do usurio do
computador para acomodar um nmero varivel de usurios. Cada usurio possui um nome, uma
senha, um nmero de identificao nico (UID), e um campo indicando quando ele possui privilgios
de administrador. Cada elemento da lista do tipo userL, contendo toda essa informao do
usurio juntamente com uma ligao para o prximo elemento da lista. Um ponteiro para a cabea
da lista armazenado numa varivel global chamada users, e inicialmente definida como NULL
para indicar que no existem usurios.
O programa define funes para inserir, excluir e localizar um usurio, e para contar o nmero de
usurios. A funo insertUser aloca espao para um novo elemento da lista e o adiciona cabea
da lista. A funo deleteUser faz uma varredura atravs da lista at o UID especificado ser
encontrado, e ento remove aquele elemento, ajustando o link do elemento anterior para pular o
elemento excludo. A funo findUser faz uma varredura na lista at a UID especificada ser
encontrada, e retorna um ponteiro para aquele elemento, ou NULL se o UID no for encontrado. A
funo numUsers conta o nmero de elementos na lista.
Exemplo de Cdigo C.39 LISTA LIGADA

#include <stdlib.h>
#include <string.h>
typedef struct userL {
char uname[80]; // nome de usuario

char passwd[80]; // senha
int uid; // nmero de id. do usuario
int admin; // 1 indica privilgios de administrador
919
struct userL *next;
} userL;
userL *users = NULL;
void insertUser(char *uname, char *passwd, int uid, int admin) {

userL *newUser;
newUser = malloc(sizeof(userL)); // cria espaco para novo usuario
strcpy(newUser->uname, uname); // copia valores nos campos do usuario
strcpy(newUser->passwd, passwd);
newUser->uid = uid;
newUser->admin = admin;
newUser->next = users; // insere no incio da lista ligada
users = newUser;
}
void deleteUser(int uid) { // exclui primeiro usuario com dado uid

userL *cur = users;
userL *prev = NULL;
while (cur != NULL) {

if (cur->uid = = uid) { // encontra usuario para excluir
if (prev = = NULL) users = cur->next;
else prev->next = cur->next;
free(cur);
return; // feito
}
prev = cur; // caso contrrio, continuar varrendo lista
cur = cur->next;
}
}
userL *findUser(int uid) {

userL *cur = users;
920

if (cur->uid = = uid) return cur;
else cur = cur->next;
}
return NULL;
}
int numUsers(void) {
userL *cur = users;
int count = 0;

count++;
cur = cur->next;
}
return count;
}
Resumo
Ponteiros: Um ponteiro mantm o endereo de uma varivel.
Arrays: Um array uma lista de elementos similares declarados utilizando-se colchetes [].
Caracteres: tipos char podem manter pequenos inteiros ou cdigos especiais para
representar textos ou smbolos.
Strings: Uma string um array de caracteres terminado com uma terminao NULL 000.
Estruturas: Uma estrutura armazena uma coleo de variveis relacionadas.
Alocao dinmica de memria: malloc uma funo built-in para alocao dinmica
de memria conforme o programa executado. free liberta a memria aps o uso.
Listas Ligadas: Uma lista ligada uma estrutura de dados comum para armazenamento de
um nmero varivel de elementos.
921
C.9 BIBLIOTECAS PADRO

Programadores comumente utilizam uma variedade de funes padro, como de impresso e
trigonomtricas. Para libertar o programador de ter que escrever essas funes do zero, a linguagem
C disponibiliza bibliotecas de funes frequentemente usadas. Cada livraria possui um arquivo de
cabealho (header) e um arquivo objeto associado, o qual um arquivo C parcialmente compilado.
O arquivo de cabealho mantm as declaraes de variveis, tipos definidos, e prottipos de
funes. O arquivo objeto contm as funes em si, e ligado no momento da compilao para criar
o executvel. Devido s chamadas de funes das bibliotecas serem compiladas num arquivo objeto,
o tempo de compilao reduzido. A Tabela C.5 lista algumas das bibliotecas em C mais
frequentemente utilizadas, e cada uma descrita brevemente abaixo.
C.9.1 stdio
A biblioteca padro de entrada/sada (Standard input/output), stdio.h, contm comandos
para imprimir na consola, ler entradas do teclado, e ler e escrever arquivos. Para usar essas funes,
a biblioteca deve ser includa no topo do arquivo C:
#include <stdio.h>
printf
A declarao print formatted, printf, mostra texto na consola. O seu argumento de entrada
requerido uma string entre aspas . A string contm texto e comandos opcionais para imprimir
variveis. Variveis a serem impressas so listadas aps a string, e so impressas utilizando os
cdigos de formato mostrados na Tabela C.6. O Exemplo de Cdigo C.40 d um exemplo simples da
funo printf.
922
Tabela C.5 Bibliotecas C frequentemente usadas
923
Tabela C.6 Cdigos de formato de printf para a impresso de variveis
Exemplo de Cdigo C.40 IMPRIMINDO NA CONSOLA UTILIZANDO PRINTF

// Simples funo de impresso
#include <stdio.h>
int num = 42;
int main(void) {
printf("A resposta %d.\n", num);
}
Sada da Consola:
A resposta 42.
924
Formatos em vrgula flutuante (floats e doubles), por padro, tem seis dgitos impressos
aps o ponto decimal. Para mudar essa preciso, substitua %f por %w.df, onde w o tamanho
mnimo do nmero, e d o nmero de casas decimais a serem impressas. Note que o ponto decimal
est includo na contagem do tamanho. No Exemplo de Cdigo C.41, pi impresso com um total de
quatro caracteres, dois dos quais esto aps o ponto decimal: 3.14. A varivel e impressa com um
total de oito caracteres, trs deles esto depois do ponto decimal. Devido a ele possuir apenas um
dgito antes do ponto decimal, ele coberto com trs espaos para atingir a largura requisitada. A
varivel c deve ser impressa com cinco caracteres, trs dos quais esto aps o ponto decimal. Mas
ela muito grande para arredondar, ento a largura requisitada substituda enquanto so retidos
os trs dgitos aps o ponto decimal.
Exemplo de Cdigo C.41 FORMATOS DE IMPRESSO DE NMEROS EM VRGULA FLUTUANTE

// Imprima nmeros em vrgula flutuante com diferentes formatos
float pi = 3.14159, e = 2.7182, c = 2.998e8;

printf("pi = %4.2f\ne = %8.3f\nc = %5.3f\n", pi, e, c);
Sada da Consola:
pi = 3.14
e = 2.718
c = 299800000.000
Devido % e \ serem usadas na formatao de impresso, para imprimir esses caracteres, o leitor
deve utilizar a sequncia especial de caracteres mostrada no Exemplo de Cdigo C.42.
Exemplo de Cdigo C.42 IMPRIMIR % E \ UTILIZANDO PRINTF

// Como imprimir % e \ na consola
printf("Aqui esto alguns caracteres especiais: %% \\ \n");
Sada da Consola:
Aqui esto alguns caracteres especiais: % \
925
scanf
A funo scanf l textos digitados no teclado. Ela utiliza cdigos de formatao do mesmo
modo que printf. Exemplo de Cdigo C.43 mostra como utilizar a funo scanf. Quando a
funo scanf encontrada, o programa espera at que o usurio digite um valor, antes de
continuar sua execuo. Os argumentos de scanf so uma string indicando um ou mais cdigos
de formatao, e ponteiros para as variveis onde os resultados devem ser armazenados.
Exemplo de Cdigo C.43 LENDO ENTRADA DO TECLADO COM SCANF

// L variveis da linha de comando
#include <stdio.h>
int main(void)
{
int a;
char str[80];
float f;
printf("Entre com um inteiro.\n");
scanf("%d", &a);
printf("Entre com um numero em vrgula flutuante.\n");
scanf("%f", &f);
printf("Entre com uma string.\n");
scanf("%s", str); // note que & no necessrio: str um ponteiro
Manipulao de Arquivos
Muitos programas precisam ler e escrever arquivos, seja para manipular dados j armazenados
num arquivo ou para carregar grandes quantidades de informao. Em C, o arquivo deve ser aberto
com a funo fopen. Ele pode ento ser lido ou editado com fscanf ou fprintf de modo
anlogo a ler e escrever na consola. Finalmente, ele deve ser fechado com o comando fclose.
A funo fopen toma como argumentos o nome do arquivo e o modo de impresso. Ela retorna
um ponteiro de arquivo ou tipo FILE*. Se fopen est impossibilitada de abrir o arquivo, ela
926
retorna NULL. Isso deve acontecer quando algum tenta abrir um arquivo no existente, ou escrever
num arquivo que j est aberto por outro programa. Os modos so:
w: Escreve num arquivo. Se o arquivo existe, ele sobrescrito.
r: L de um arquivo.
a: acrescenta ao fim de um arquivo existente. Se o arquivo no existe, ele criado.

O Exemplo de Cdigo C.44 mostra como abrir, imprimir, e fechar um arquivo. uma boa prtica
sempre verificar se o arquivo foi aberto com sucesso, e providenciar uma mensagem de erro se no
foi. A funo exit ser discutida na Seo . 9.2.2. A funo fprintf parecida com a printf, idiomtico abrir um arquivo e verificar
mas ela tambm toma um ponteiro de arquivo como argumento de entrada para saber em qual se o ponteiro e arquivo NULL em uma
arquivo escrever. fclose fecha o arquivo, garantindo que toda a informao foi efetivamente nica linha de cdigo, como mostrado no
escrita no disco e libertou os recursos do sistema de arquivos. Exemplo de Cdigo C.44. Entretanto, voc
pode simplesmente separar a
Exemplo de Cdigo C.44 IMPRIMINDO NUM ARQUIVO UTILIZANDO FPRINTF funcionalidade em duas linhas:
// Escreva Testando escrita em arquivo em result.txt fptr = fopen(result.txt,w);

#include <stdio.h>
if (fptr = = NULL)
#include <stdlib.h>
int main(void) { ...
FILE *fptr;
if ((fptr = fopen("result.txt", "w")) == NULL) {

printf("Impossivel abrir result.txt para escrita.\n");
exit(1); // sai do programa indicando execuo malsucedida
}
fprintf(fptr, "Testando escrita em arquivo.\n");
fclose(fptr);
}
O Exemplo de Cdigo C.45 ilustra a leitura de nmeros de um arquivo chamado data.txt utilizando
a funo fscanf. O arquivo deve ser aberto para leitura. O programa ento utiliza a funo feof
927
para verificar se ele atingiu o fim do arquivo. Enquanto o programa no chega ao fim, ele l o
prximo nmero e o imprime na tela. Novamente, o programa fecha o arquivo no final, para liberar
recursos.
Exemplo de Cdigo C.45 LENDO A ENTRADA DE UM ARQUIVO UTILIZANDO FSCANF

#include <stdio.h>
int main(void)
{
FILE *fptr;
int data;
// le dado do arquivo de entrada
if ((fptr = fopen("data.txt", "r")) == NULL) {
printf("Impossivel ler dado.txt\n");
exit(1);
}
while (!feof(fptr)) { // checa que o fim do arquivo no foi atingido ainda

fscanf(fptr, "%d", &data);
printf("Le dado: %d\n", data);
}
fclose(fptr);
}
Sada da Consola:
Le dado: 25
Le dado: 32
Le dado: 14
Le dado: 89
928
Outras funes stdio Convenientes
A funo sprintf imprime caracteres em uma string, e sscanf l variveis de uma string. A
funo fgetc l um nico caractere de um arquivo, enquanto fgets l uma linha completa de uma
string.
fscanf bastante limitada na sua capacidade de ler e analisar arquivos complexos, ento,
frequentemente mais fcil usar fgets numa linha por vez e ento resumir aquela linha usando
sscanf, ou com um loop que inspecione caracteres um por vez utilizando fgetc.
C.9.2 stdlib
A biblioteca padro stdlib fornece funes de propsito geral, incluindo a gerao aleatria de
nmeros (rand e srand), alocao dinmica de memria (malloc e free, j discutidas na Seo
C.8.8, sada do programa (exit), e converso entre formatos de nmeros. Para utilizar essas funes,
adicione a seguinte linha de cdigo no topo do arquivo C.
#include <stdlib.h>
rand e srand
rand retorna um inteiro pseudo-aleatrio. Nmeros pseudo-aleatrios possuem a estatstica dos

nmeros aleatrios, mas seguem um padro determinstico comeando com um valor inicial
denominado semente (seed). Para converter o nmero numa faixa particular, use o operador mdulo
(%) como mostrado no Exemplo de Cdigo C.46 para uma faixa de 0 a 9. Os valores x e y sero
aleatrios, mas eles sero os mesmos a cada vez que o programa for executado. Amostras de sadas
da consola so dadas abaixo do cdigo.
Exemplo de Cdigo C.46 GERAO DE NMEROS ALEATRIOS UTILIZANDO RAND

#include <stdlib.h>
int x, y;
x = rand(); // x = um inteiro aleatorio

y = rand() % 10; // y = um numero aleatrio de 0 a 9
929
printf(x = %d, y = %d\n, x, y);
Sada da Consola:
Por razes histricas, a funo time x = 1481765933, y = 3
usualmente retorna o tempo atual em
segundos relativo ao dia 1 de Janeiro de 1970, Um programador cria uma sequncia diferente de nmeros aleatrios cada vez que o programa
00:00 UTC UTC significa Coordinated Universal executado atravs da mudana da semente. Isso feito pela chamada da funo srand, que toma
Time, o qual o mesmo que o Tempo mdio
o valor da semente como argumento de entrada. Como mostrado no Exemplo de Cdigo C.47, a
de Greenwich (GMT). Essa data logo aps o
sistema operacional UNIX ser criado por um semente por si s deve ser aleatria, ento, um programa tpico em C a atribui pela chamada da
grupo no Bell Labs, incluindo Dennis Ritchie e funo time, que retorna o tempo atual em segundos.
Brian Kernighan, em 1969. Similarmente s
festas de vsperas do Ano Novo, alguns Exemplo de Cdigo C.47 SEMEANDO O GERADOR DE NMEROS ALEATRIOS USANDO SRAND
entusiastas UNIX mantm festas para celebrar
#include <stdlib.h>
valores significativos retornados por time.
int x, y;
Por exemplo, no dia 1 de fevereiro de 2009, s
23:31:30 UTC, time retornou o valor
1,234,567,890. No ano 2038, os relgios UNIX x = rand(); // x = um inteiro aleatrio
iro ter overflow e voltar ao ano de 1901. y = rand() % 10; // y = um nmero aleatrio de 0 a 9
printf(x = %d, y = %d\n, x, y);
Sada da Consola:
x = 1481765933, y = 3
exit
A funo exit termina o programa antecipadamente. Ela toma um nico argumento que
retornado ao sistema operacional, indicando a razo do trmino. O valor zero indica realizao
normal, enquanto um valor diferente de zero indica uma condio de erro.
930
Converso de Formatos: atoi, atol, atof

A biblioteca padro fornece funes para converter strings ASCII em inteiros, inteiros longos, ou
doubles usando atoi, atol e atof, respectivamente, como mostrado no Exemplo de Cdigo
C.48. Isso particularmente til quando se est lendo dados misturados (uma mistura de strings e
nmeros) de um arquivo, ou nos argumentos da linha de comando para processamento numrico,
como descrito na Seo C.10.3.
Exemplo de Cdigo C.48 CONVERSO DE FORMATO

// Converter strings ASCII em ints, longs e floats
#include <stdlib.h>
int main(void)
{
int x;
long int y;
double z;
x = atoi("42");
y = atol("833");
z = atof("3.822");
printf("x = %d\ty = %d\tz = %f\n", x, y, z);
}
Sada da Consola:
x = 42 y = 833 z = 3.822000
931
C.9.3 math
A biblioteca matemtica math.h fornece funes matemticas comumente utilizadas, como
funes trigonomtricas, raiz quadrada e logaritmos. O Exemplo de Cdigo C.49 mostra como utilizar
algumas dessas funes. Para utilizar funes matemticas, coloque a seguinte linha no arquivo C:
#include <math.h>
Exemplo de Cdigo C.49 FUNES MATEMTICAS

// funes matemticas
#include <stdio.h>
#include <math.h>
int main(void) {
float a, b, c, d, e, f, g, h;
a = cos(0); // 1, note: o argumento de entrada esta em radianos
b = 2 * acos(0); // pi (acos significa arc cosseno)
c = sqrt(144); // 12
d = exp(2); // e^2 = 7.389056,
e = log(7.389056); // 2 (logaritmo natural, base e)
f = log10(1000); // 3 (log base 10)

g = floor(178.567); // 178, arredondado para o menor inteiro mais proximo
h = pow(2, 10); // computa 2 elevado a decima potencia
printf("a = %.0f, b = %f, c = %.0f, d = %.0f, e = %.2f, f = %.0f, g = %.2f, h =

%.2f\n",a, b, c, d, e, f, g, h);
}
Sada da Consola:
a = 1, b = 3.141593, c = 12, d = 7, e = 2.00, f = 3, g = 178.00, h = 1024.00
932
C.9.4 string
A biblioteca string.h fornece funes de manipulao de strings comumente utilizadas. Funes
chave incluem:
// copia src em dst e retorna dst
char *strcpy(char *dst, char *src);
// concatena src ao fim de dst e retorna dst
char *strcat(char *dst, char *src);
// compara duas strings. Retorna 0 se igual, nonzero caso contrrio
int strcmp(char *s1, char *s2);
// retorna o comprimento de str, no incluindo o terminador null
int strlen(char *str);
C.10 COMPILADOR E OPES DA LINHA DE COMANDO

Embora ns tenhamos introduzidos programas em C relativamente simples, os programas do mundo
real podem consistir de dezenas, ou at mesmo milhares de arquivos C para permitir a modularidade
e legibilidade a mltiplos programadores. Essa seo descreve como compilar um programa espalhado
por mltiplos arquivos C, e mostra como utilizar as opes do compilador e os argumentos da linha de
comando.
C.10.1 Compilando Mltiplos Arquivos Fonte C
Mltiplos arquivos C so compilados num nico executvel listando-se todos os nomes dos arquivos
na linha do compilador, como mostrado abaixo. Lembre-se que o grupo de arquivos C devem conter
uma nica funo main, convencionalmente colocada num arquivo nomeado como main.c.
gcc main.c file2.c file3.c
C.10.2 Opes do Compilador

As opes do compilador permitem ao programador especificar algumas coisas, como nomes e
formato dos arquivos de sada, otimizaes, etc. As opes do compilador no so padronizadas, mas
a Tabela C.7 lista algumas das mais comumente utilizadas. Cada opo tipicamente precedida por um
933
trao (-) na linha de comando, como mostrado. Por exemplo, a opo -o permite ao programador
especificar um nome ao arquivo de sada que no seja o padro a.out. Existe uma grande
quantidade de opes; elas podem ser vistas digitando-se gcc help na linha de comando.
Tabela C.7 Opes do compilador
C.10.3 Argumentos da Linha de Comando

Assim como outras funes, main tambm pode receber variveis de entrada. No entanto, ao
contrrio de outras funes, esses argumentos so especificados na linha de comando. Como
mostrado no Exemplo de Cdigo C.50, argc significa uma contagem de argumento, e denota o
nmero de argumentos na linha de comando. argv significa vetor de argumentos, e um array das
strings encontradas na linha de comando. Por exemplo, suponha que o programa no Exemplo de
Cdigo C.50 compilado num executvel chamado testargs. Quando as seguintes linhas so
digitadas na linha de comando, argc tem o valor 4, e o array argv tem os valores
{"./testargs", "arg1", "25","lastarg!"}. Note que o nome do executvel contado
como o primeiro argumento. A sada da consola aps a digitao desse comando mostrada abaixo
no Exemplo de Cdigo C.50.
934
gcc -o testargs testargs.c

./testargs arg1 25 lastarg!
Habilidades de depurao so adquiridas
Os programas que necessitam de argumentos numricos podem converter as strings de argumentos com o tempo, mas aqui esto algumas
em nmeros utilizando as funes em stdlib.h. dicas:
Exemplo de Cdigo C.50 ARGUMENTOS DA LINHA DE COMANDO - Conserte erros comeando com o
primeiro indicado pelo compilador. Erros
// Imprime os argumentos da linha de comando
#include <stdio.h> seguintes podem ser erros de efeito
int main(int argc, char *argv[]) devido ao primeiro. Aps consertar
{ aquele bug, recompile e repita at que
int i; todos os bugs (pelo menos aqueles
for (i=0; i<argc; i++) detectados pelo compilador!) sejam
printf("argv[%d] = %s\n", i, argv[i]);
consertados.
}
- Quando o compilador informa que uma
Sada da Consola: linha vlida no cdigo possui um erro,
cheque o cdigo acima dela (isto , por
argv[0] = ./testargs
pontos e vrgulas e chaves faltantes).
argv[1] = arg1
argv[2] = 25 - Quando necessrio, quebre declaraes
argv[3] = lastarg!
complicadas em mltiplas linhas.
C.11 ERROS COMUNS - Use printf para mostrar resultados

intermedirios.
Assim como em qualquer linguagem de programao, voc est quase certo de que vai cometer - Quando um resultado no atinge suas
erros enquanto escreve programas no triviais em C. Abaixo esto algumas descries de alguns erros expectativas, comece a depurar o cdigo
comuns cometidos quando programamos em C. Alguns desses erros so particularmente no primeiro lugar onde ele devia atender
problemticos, pois so compilados, mas no funcionam como o programador pretendia. s expectativas.
- Olhe para todas as advertncias do

compilador. Enquanto algumas
advertncias podem ser ignoradas, outras
podem alertar para erros mais sutis no
cdigo que iro compilar, mas no
executar como o esperado
935
Erro de Cdigo C.1 ESQUECER & EM SCANF

Cdigo Errado Cdigo Correto
int a; int a;
printf("Entre com um inteiro:\t"); printf("Entre com um inteiro:\t");
scanf("%d", a); // falta & antes de a scanf("%d", &a);
Erro de Cdigo C.2 USAR = AO INVS DE == PARA COMPARAO

if (x = 1) // sempre definido como TRUE if (x == 1)
printf("Encontrado!\n"); printf("Encontrado!\n");
Erro de Cdigo C.3 INDEXAR ELEMENTOS APS O LTIMO NDICE DO ARRAY

int array[10]; int array[10];
array[10] = 42; // index entre 0-9 array[9] = 42;
Erro de Cdigo C.4 USAR = NA DECLARAO #DEFINE

// substitui NUM por "= 4" no cdigo #define NUM 4
#define NUM = 4
Erro de Cdigo C.5 USAR UMA VARIVEL NO INICIALIZADA

int i; int i = 10;
if (i == 10) // i no foi inicializada if (i == 10)
... ...
936
Erro de Cdigo C.6 NO INCLUIR O CAMINHO DE CABEALHOS CRIADOS PELO USURIO

#include "myfile.h" #include "othercode\myfile.h"
Erro de Cdigo C.7 USAR OPERADORES LGICOS (!, ||, &&) AO INVS DE OPERADORES BIT A BIT (~, |, &)
char x=!5; // lgico NOT: x = 0 char x=~5; // bit a bit NOT: x = 0b11111010
char y=5||2; // lgico OR: y = 1 char y=5|2;// bit a bit OR: y = 0b00000111
char z=5&&2; // lgico AND: z = 1 char z=5&2;// lgico AND: z = 0b00000000
Erro de Cdigo C.8 ESQUECER BREAK EM UMA DECLARAO SWITCH/CASE

char x = 'd'; char x = 'd';
... ...
switch (x) { switch (x) {
case 'u': direction = 1; case 'u': direction = 1; break;
case 'd': direction = 2; case 'd': direction = 2; break;
case 'l': direction = 3; case 'l': direction = 3; break;
case 'r': direction = 4; case 'r': direction = 4; break;
default: direction = 0; default: direction = 0;
} }
// direction = 0 // direction = 2
Erro de Cdigo C.9 ESQUECER AS CHAVES

if (ptr == NULL) // chaves esquecidas if (ptr == NULL) {
printf("Impossvel abrir arquivo.\n"); printf("Impossvel abrir arquivo.\n");
exit(1); // sempre executa exit(1);
}
937
Erro de Cdigo C.10 USAR UMA FUNO ANTES DA MESMA SER DECLARADA
int main(void) void test(void)
{ {...
test(); }
} int main(void)
void test(void) {
{... test();
} }
Erro de Cdigo C.11 DECLARAR UMA VARIVEL GLOBAL E UMA LOCAL COM O MESMO NOME
int x = 5; // declarao global de x int x = 5; // declarao global de x
int test(void) int test(void)
{ {
int x = 3; // declarao local de x int y = 3; // declarao local de y...
... }
}
Erro de Cdigo C.12 TENTAR INICIALIZAR UM ARRAY COM { } APS A DECLARAO

int scores[3]; int scores[3] = {93, 81, 97};
scores = {93, 81, 97}; // no compila
Erro de Cdigo C.13 ATRIBUIR UM ARRAY A OUTRO UTILIZANDO =

int scores[3] = {88, 79, 93}; int scores[3] = {88, 79, 93};
int scores2[3]; int scores2[3];
scores2 = scores; for (i=0; i<3; i++)
scores2[i] = scores[i];
938
Erro de Cdigo C.14 ESQUECER UM PONTO E VRGULA APS UM LOOP DO/WHILE

int num; int num;
do { do {
num = getNum(); num = getNum();
} while (num < 100) // falta ; } while (num < 100);
Erro de Cdigo C.15 UTILIZAR VRGULAS AO INVS DE PONTO E VRGULA NUM LOOP FOR
for (i=0, i < 200, i++) for (i=0; i < 200; i++)
... ...
Erro de Cdigo C.16 DIVISO INTEIRA AO INVS DE DIVISO EM VRGULA FLUTUANTE

// diviso inteira (truncada) ocorre quando // ao menos um dos argumentos da
// ambos os argumentos da diviso so inteiros // diviso deve ser um float para
float x = 9 / 4; // x = 2.0 // realizar diviso em vrgula flutuante
float x = 9.0 / 4; // x = 2.25
Erro de Cdigo C.17: ESCREVER NUM PONTEIRO NO INICIALIZADO

int *y = 77; int x, *y = &x;
*y = 77;
Erro de Cdigo C.18 GRANDES EXPECTATIVAS (OU A FALTA DELA)

Um erro comum de iniciantes escrever um programa inteiro (usualmente com pouca modularidade) e esperar que ele funcione perfeitamente da primeira vez. Para
programas no triviais, escrever um cdigo modular e testar as funes individualmente ao longo do caminho essencial. A depurao se torna exponencialmente mais
difcil, e consome mais tempo, com a complexidade.
939
Outro erro comum a falta de expectativa. Quando isso acontece, o programador pode somente verificar que o cdigo produz um resultado, no que aquele resultado
correto. Testar um programa com entradas conhecidas e esperar resultados crtico na verificao de funcionalidade.
Este apndice foi focado na utilizao de C num sistema com uma consola, como um computador
com Linux. A Seo 8.6 descreve como C utilizado para programar microcontroladores 32
utilizados em sistemas embarcados. Os microcontroladores so usualmente programados em C pois
essa linguagem fornece um controle de baixo nvel do hardware quanto a linguagem assembly, ainda
que muito mais sucinto e rpido de escrever.
940
D Processador MIPSfpga
D.1 INTRODUO
O MIPSfpga um processador MIPS32 microAptiv da Imagination para uso educacional com cache e
unidade de gerenciamento de memria. disponibilizada uma implementao deste processador em
cdigo Verilog adequada para simulao e implementao numa FPGA.
Os processadores MIPS tm sido utilizados em produtos comerciais e estudados por estudantes de
arquitetura de computador ao longo de dcadas. Este anexo introduz o primeiro ncleo MIPS comercial
disponvel gratuitamente. A arquitetura MIPS aqui introduzida e os seus aspectos mais relevantes so
apresentados. A Imagination disponibiliza atravs da sua plataforma educacional, aps o registo gratuito,
para alm do cdigo de implementao, vrios exemplos ilustrativos.
Este anexo pretende introduzir o leitor a esta ferramenta educacional. Pretende-se realar o seu
potencial educativo atravs da ilustrao do seu funcionamento. Dado o modo como foi concebido, o
processador MIPSfpga pode ser explorado de vrias formas: simulao do funcionamento interno do
processador; verificao do funcionamento real numa FPGA; ou utilizando uma FPGA conjuntamente com
um programador JTAG para analisar e depurar o funcionamento do sofware.
Este anexo comea por apresentar os passos necessrios para obter gratuitamente o MIPSfpga atravs
do site do Imagination University Programme (UIP). Em seguida, fornecida uma viso geral do ncleo
MIPS onde so descritos os sinais de interface do ncleo MIPSfpga. As trs ltimas sees deste anexo
ilustram, num crescendo de complexidade, a utilizao do processador MIPSfpga.
As ferramentas tanto de software como de hardware necessrias so introduzidas, assim como o modo
de as obter e instalar. Neste ponto o leitor estar apto a comear a explorar o processador MIPSfpga.
941
Apndice D O Processador MIPSfpga
Para isso, o leitor comear por realizar no ModelSim a simulao do funcionamento do

processador MIPSfpga e executar um programa. Alguns aspectos do funcionamento interno relativos
execuo do programa sero realados.
Em seguida, sero descritos os passos necessrios instalao do processador MIPDfpga no kit de
desenvolvimento Nexys4 DDR utilizando o Xilinx Vivado 15.1. O processador MIPS ir executar um
programa com o qual foi previamente sintetizado.
Na parte final do anexo vamos ver como compilar um programa utilizando as ferramentas de
produo de software CodeScape. Este novo programa ser carregado no processador MIPSfpga
atravs do programador Bus-Blaster, e, o seu funcionamento verificado atravs de tcnicas de
depurao de cdigo.
D.1.1 Como Obter o MIPSfpga Getting Started
O IUP (Imagination University Programme) faz parte do site da Comunidade Imagination. Aqui o
leitor pode encontrar informaes sobre o IUP, os seus parceiros e futuros eventos, visualizar tutoriais
on-line, fazer o download de materiais de ensino e muito mais, tais como, encontrar fruns e outros
recursos. Para isso, o leitor deve primeiro registrar-se gratuitamente em:
http://community.imgtec.com/university/university-registration
Aps receber um e-mail de verificao deve ativar a sua conta e completar os seus dados de perfil.
Deste momento em diante pode fazer login em
Figura D.1 Seleo do pacote a https://community.imgtec.com/university/resources/
descarregar
Agora, com as suas credenciais de acesso pode descarregar os contedos do seu interesse. No nosso
caso estamos interessados no pacote MIPSfpga Getting Started em lngua inglesa (Figura D.1).
Seguindo os procedimentos indicados ir obter um ficheiro compactado
Aps receber o ficheiro deve descompactar o seu contedo no seu disco. Mantenha o ficheiro
compactado para poder repor sempre os ficheiros originais. Desta ao resultar uma estrutura como
a apresentada na Figura D.2. Os ficheiros de implementao do processador MIPSfpga esto
942
disponveis no folder rtl_up. A implementao do projeto no Xilinx Vivado para a Nexys4 DDR est
disponvel no folder Nexys4_DDR. O projeto de simulao para o ModelSim do processador
MIPSfpga est disponvel no folder ModelSim. Um instalador do Codescape e vrios exemplos de
cdigo, tanto em assembler como C, esto disponveis no folder Codescape. De especial interesse
so os scripts disponibilizados que ajudam na elaborao dos projetos como veremos em seguida.
Finalmente, no folder Documents pode ser encontrada literatura relevante para auxiliar no estudo
do processador MIPSfpga.
D.1.2 A Arquitectura MIPSfpga
A arquitetura MIPS uma das arquiteturas de computadores originais do tipo Reduced
Instruction Set (RISC). Teve a sua origem nos resultados da pesquisa desenvolvida na Universidade
de Stanford em 1981 e teve como consequncia um aumento da eficincia das arquiteturas de
computadores. Foi comercializado em 1984 pela MIPS Computer Systems e adquirida pela
Imagination Technologies em 2013.
Figura D.2 Estrutura do MIPSfpga-
Os processadores MIPS tornaram-se em 1980 e 1990 os crebros das estaes de trabalho da
Getting-Started-v1.3_1Mar2016
Silicon Graphics de alto desempenho. O MIPS R3000, com um pipeline de 5 estgios, foi o primeiro
sucesso comercial importante. Que foi seguido pelo R4000, ao qual foram adicionadas instrues
de 64-bits, o R8000 superscalar, e o R10000 out-of-order, seguidos por ncleos com desempenho
muito mais elevado.
A arquitetura MIPS evoluiu para responder s necessidades dos mercados onde as restries
energticas ou o custo so fatores determinantes, incluindo a electrnica de consumo, as redes de
dados e os microcontroladores. A famlia M4K baseia-se no clssico de 32-bits com pipeline de 5
estgios. A famlia M14K acrescentou o conjunto de instrues de 16-bits microMIPS definido para
reduzir o tamanho do cdigo para aplicaes embarcadas de baixo custo. A famlia microAptiv
estende a M14K com instrues opcionais de processamento de sinais digitais. A microAptiv est
943
disponvel nas variantes microcontrolador (UC) e microprocessador (UP), sendo que variante
microprocessador foram acrescentadas caches e memria virtual para executar sistemas operacionais
como Linux ou Android. O leitor pode estar familiarizado com a linha PIC32 popular da Microchip de
microcontroladores baseada na arquitetura M4K.
As famlias MIPS M4K, M14K e microAptiv so os ncleos mais simples de processador da
Imagination Technologies em termos de microarquitetura. No entanto, o seu software compatvel
com as linhas mid-range e high-end da Imagination, bem como com as suas variantes multi-core. A
linha de ncleos mid-range inclui o MIPS interAptiv, um ncleo de 32-bits com suporte de hardware
para multi-threading, e o dual-issue superscalar MIPS I6400 de 64-bits. A linha de ncleos high-end
inclui o multiprocessador MIPS P5600 de 32-bit, com at seis cores multiple-issue out-of-order,
extenses SIMD, e outros recursos avanados.
O ncleo MIPSfpga uma verso do microAptiv UP. Os processadores microAptiv so encontrados
numa ampla variedade de aplicaes comerciais, incluindo a automao industrial, automvel,
electrnica de consumo e as comunicaes sem fio. O ncleo MIPSfpga definido na linguagem de
descrio de hardware Verilog (HDL). designado como um processador soft core, porque descrito
em software (Verilog) em vez de ser fabricado num chip de computador. Os arquivos Verilog podem
ser encontrados no folder MIPSfpga \ rtl_up. ("RTL" significa register-transfer-logic, um termo que se
refere lgica e aos registros que descrevem o processador MIPSfpga no cdigo HDL, e "up" significa
microprocessador.)
O processador MIPSfpga possui cerca de 12k declaraes Verilog e tem as seguintes caractersticas:
Ncleo microAptiv UP correndo MIPS32 ISA com pipeline de 5 estgios e fornece 1,5
Dhrystone MIPS / MHz
Caches associativas de 2-vias para instrues e dados (2 KB cada)
Unidade de gesto de memria com TLB de 16-entradas
944
Barramento de interface AHB-Lite

Programador / depurador EJTAG, incluindo 2 breackpoints de instruo e 1 de dados
Contadores de desempenho
Sincronizadores de entrada
CorExtend para instrues definidas pelo usurio
Sem extenses de processamento de sinais digitais, interface para os registros do
coprocessador 2 ou registros sombra
O processador MIPSfpga licenciado exclusivamente para uso educacional e no comercial. Por
favor, consulte os Termos de Uso associados aos contedos que obteve. O leitor pode us-los para
aprender como um microprocessador funciona. Pode simular o cdigo Verilog ou compil-lo para
FPGA e assistir ao desempenho do processador em ao. Pode ler o cdigo e aprender sobre como
a micro-arquitetura implementada. Pode escrever e compilar programas em linguagem assembly
ou C e v-los a serem executados num simulador de Verilog ou numa FPGA. O leitor pode fazer a
interface com perifricos ou outros ncleos atravs do barramento AHB-Lite e aprender sobre o
projeto de system-on-chip. Pode modificar o cdigo para explorar a implementao de novas
instrues ou variaes microarquiteturais. Pode at mesmo arrancar com o Linux para ver todo o
sistema em funcionamento desde o Verilog at ao sistema operacional.
O microAptiv executa a verso MIPSr3 do conjunto de instrues MIPS. O pipeline e o conjunto
de instrues so descritos em detalhe no Manual do Utilizador de Software
(MIPSfpga\Documents\MicroAptiv UP Software User's Manual MD00924.pdf). Esta seo resume os
aspectos principais e descreve como o ncleo est ligado memria e dispositivos de I/O.
A Figura D.3 mostra um diagrama do processador MIPSfpga. A parte central do processador a
Execution Unit. Ela executa as operaes ordenadas pelas instrues, tais como adicionar ou
subtrair. A MDU (multiply/divide unit) uma extenso daquela unidade que executa as operaes
de multiplicao e diviso. O bloco Instruction Decoder recebe as instrues a partir da cache de
instrues e gera sinais para fazer com que a unidade de execuo execute a operao. A unidade
System Co-Processor fornece os sinais de interface do sistema, como o relgio do sistema e o reset.
A unidade GPR suporta os registros de uso geral utilizados como operandos das instrues.
945
Figura D.3 O ncleo MIPSfpga

As outras interfaces na parte superior da Figura D.3 (UDI, COP2 e Interrupt Interfaces) permitem
que o processador execute instrues definidas pelo usurio (como descrito na Folha de dados
encontrada em MIPSfpga\Documents\MicroAptiv UP Datasheet MD00929.pdf), para fazer a interface
com uma unidade co-processador 2, e receber interrupes externas, respectivamente.
As caches de instruo e de dados (I-Cache e D-cache) esto conectadas aos seus respectivos
controladores e a uma unidade de gesto de memria (MMU). A MMU executa a traduo de
endereos de memria e recupera os dados ou as instrues da memria quando os dados no
esto disponveis na cache. A BIU (bus interface unit) permite que o usurio possa anexar memrias
e I/O mapeado na memria ao processador atravs de um barramento AHB-Lite.
As interfaces das RAM de dados e de instrues (Interfaces D-SRAM e I-SRAM) permitem o
acesso de baixa latncia do processador a memrias em chip, conforme descrito no Guia do
MicroAptiv UP Integrator (MIPSfpga\Documents\MicroAptiv UP Integrator's Guide MD00941.pdf).
946
Tabela D.1 O pipeline do MIPSfpga
Nmero Estgio Nome Descrio

1 I Instruction O processador obtm uma instruo
O processador obtm os operandos a partir do banco de
2 E Execution registros e executa uma operao da ALU (por exemplo,
adio, subtrao, ou clculo de endereo de memria)
Se for o caso, o processador acede a um operando de

3 M Memory
memria
Se for o caso, os dados carregados so alinhados com o
4 A Align
limite de palavra
Se for o caso, o processador escreve o resultado para o
5 W Writeback
banco de registros
A unidade Debugger and Profiler disponibiliza a interface EJTAG1 para depurao, bem como
monitoramento de desempenho e download de cdigo para o processador.
O ncleo do MIPSfpga tem um pipeline de 5 estgios. A Tabela D.1 apresenta cada um dos estgios
de pipeline com uma breve descrio de cada estgio.
O processador MIPSfpga tem um espao de endereamento de 32-bits e trs modos de operao:
kernel, user, e debug. Em reset, o processador comea no modo kernel e salta para o vetor de reset no
endereo 0xbfc00000. A Figura D.4 mostra um mapa da memria do processador. O endereo
0xbfc00000 est no segmento de kernel 1 (kseg1), que uncached e no mapeado. Isto significa que
todas as instrues sero obtidas a partir da memria externa, em vez das caches e que o segmento
tem um mapeamento fixo dos endereos virtuais para endereos fsicos em vez de usar a MMU, o que
importante, porque as caches e a MMU ainda no foram inicializadas imediatamente aps o reset. A Figura D.4 Mapa de memria
tabela de mapeamento dos endereos fixos mapeia o kseg1 para o endereo fsico 0x00000000
subtraindo 0xa0000000 ao endereo virtual. Assim, aps o reset, o programa comea a executar o
cdigo fora da memria principal a partir do endereo fsico 0x1fc00000. O Manual do Usurio do
947
Software (MIPSfpga\Documents\MicroAptiv UP Software User's Manual 00942.pdf) fornece informao

adicional relativa ao mapeamento da memria.
A Figura D.6 mostra um diagrama de blocos das componentes principais do processador MIPSfpga.
O sistema recebe o relgio, o reset e os sinais de programao EJTAG a partir de uma FPGA ou de um
ficheiro de simulao. Ele interage com LED ou interruptores externos, e dirige os sinais do
barramento de interface. Dentro do bloco mipsfpga_sys est o ncleo m14k_top microAptiv e o bloco
mipsfpga_ahb contendo a RAM, entradas de I/O de uso geral (GPIO), e a lgica de interface com o
AHB-Lite Bus.
Figura D.6 Sistema MIPSfpga

A Figura D.5 mostra o mapa de memria fsica fornecida pelo bloco mipsfpga_ahb. Ele contm um
Figura D.5 Mapa de memria fsica bloco de RAM com 128 KB em 0x1fc00000 inicializada com o cdigo a ser executado aps o reset do
do processador MIPSfpga processador e outro bloco de RAM de 256 KBRAM em 0x00000000 para outro cdigo ou dados. Ele
contm tambm quatro registros GPIO que controlam LED e interruptores. O cdigo de linguagem
mquina para executar aps a o reset carregado a partir do arquivo ram_reset_init.txt no arranque
ou pode ser carregado atravs do EJTAG.
D.1.3 Sinais de Interface no Processador MIPSfpga
O processador MIPSfpga tem trs interfaces principais: o barramento AHB-Lite, o I/O da placa
FPGA, e a interface EJTAG. O barramento AHB-Lite conecta o ncleo MIPSfpga memria e
dispositivos perifricos. A interface de entrada/sadas (I/O) da placa FPGA permite que o ncleo
948
MIPSfpga possa ter acesso aos interruptores e aos LED nas placas FPGA, e a interface EJTAG usada para
fazer o download de programas no ncleo MIPSfpga e depurar aplicaes em tempo real.
A Tabela D.2 lista as interfaces do processador MIPSfpga. Estes sinais usam prefixos com significados
especficos:
SI: Sinal de interface do sistema
IO: Sinais de I/O para a placa FPGA
H: Sinais do barramento AHB-Lite
EJ: Sinais de interface EJTAG
Tabela D.2 Sinais de interface com o processador MIPSfpga
949
O sinal de relgio (SI_ClkIn) o relgio de sistema para o processador. O processador MIPSfpga

funciona a 50 MHz na placa Nexys4 DDR usando um sinal de 100 MHz da Nexys4 DDR. O sinal de
reinicializao (SI_Reset_N) ativo a baixo (indicado pelo sufixo "_N"). Pressionando o boto de reset
CPU_RESETN na Nexys4 DDR faz o reset do processador. O processador deve ser reiniciado aps o power-
up. Outros sinais podem ser encontrados no Integrator's Guide (MIPSfpga\Documents\MicroAptiv UP
Integrator's Guide MD009241.pdf).
Interface AHB-Lite
O Advanced High-performance Bus (AHB) uma interface open-source usada em muitos
microprocessadores, particularmente em sistemas embarcados. O barramento AHB facilita a conexo de
vrios dispositivos ou perifricos. O AHB-Lite uma verso mais simples do AHB com um barramento de
mestre nico. Para informao mais detalhada consulte o AHB-Lite Interface Guide
(MIPSfpga\Documents\MicroAptiv UP AHB-Lite interface MD01082.pdf).
Figura D.7 Mapa de memria fsica do processador MIPSfpga

A Figura D.7 mostra o barramento AHB-Lite no processador MIPSfpga. Esta configurao tem um
mestre, o processador MIPSfpga, e trs escravos, RAM0, RAM1, e GPIO - que so dois blocos de memria
Figura D.8 AHB-Lite Write
950
RAM e um mdulo para aceder ao I/O (interruptores e LED) na placa FPGA. O processador, o mestre,
produz os sinais de relgio (HCLK), permitir escrever (HWRITE), endereo (HADDR), e escrever os sinais
de dados (HWDATA). O processador recebe os dados lidos (HRDATA) a partir de um dos escravos,
dependendo do endereo. O decodificador de endereos ativa o sinal NSE a alto para selecionar o
dispositivo escravo indicado pelo endereo.
Uma transao AHB-Lite ocorre em dois ciclos de relgio: uma fase de endereos e uma fase de
dados. Durante a fase de endereos, o mestre envia o endereo em HADDR e ativa HWRITE para uma
gravao ou desativa para uma leitura. Durante a fase de dados o mestre envia em HWDATA numa
gravao ou o escravo envia em HRDATA numa leitura. A Figura D.8 e a Figura D.9 mostram as formas
de onda para um processador realizar uma gravao e leitura, respectivamente.
Para o processador MIPSfpga, os mdulos escravos e decodificador de endereo esto localizados
no mdulo mipsfpga_ahb (encontrado no ficheiro mipsfpga_ahb.v) e os seus sub-mdulos. A RAM0
contm a memria de instruo que acedida aps o arranque. No reset, o processador define o PC
com o endereo de instruo da exceo de reset: endereo fsico 0x1fc00000 (0xbfc00000 endereo
virtual). A RAM1 contm memria acessvel de programa a partir do endereo fsico 0. O mdulo GPIO
escravo interage com o I/O da placa FPGA.
Interface de I/O da FPGA
A placa Nexys4 DDR disponibiliza LED e switches que esto ligados FPGA. O mdulo de I/O de uso
general no barramento AHB-Lite grava e l a partir do I/O da placa FPGA (LED, interruptores, etc.)
usando memria de I/O mapeada. Na memria de I/O mapeada, o processador acede a um dispositivo
de I/O, tambm chamado de perifrico, da mesma forma que acede memria, com cada perifrico
mapeado para um endereo de memria em particular. A Tabela D.3 lista os endereos de memria
de I/O para a placa FPGA Nexys4. O endereo virtual usado pelas instrues MIPS e o endereo fsico
o que aparece em HADDR no barramento AHB-Lite.
Figura D.9 AHB-Lite read
951
Tabela D.3 Endereos do mapeamento de memria para o I/O das placas FPGA
Interface EJTAG
O EJTAG um protocolo que permite (1) a depurao baseada em hardware e programas (2)
download de software num ncleo MIPS. Os sinais de interface, chamados coletivamente de Test
Access Port (TAP), so: TCK, TDI, TDO, TMS e TRST. O EJTAG utiliza as funcionalidades destes sinais,
tal como definido no protocolo JTAG, como listado abaixo:
EJ_TCK: Relgio de teste
EJ_TMS: Test Mode Select seleciona o modo de operao
EJ_TDI: Test Data In entrada de dados no processador
EJ_TDO: Test Data Out sada de dados do processador
EJ_TRST_N_probe: Test Reset, ativo a baixo provoca o reset do controlador EJTAG
O EJTAG define ainda um sinal de requisio de interrupo de debug, EJ_DINT.
D.2 OBTER E INSTALAR AS FERRAMENTAS DE TRABALHO

Para realizar as tarefas definidas neste anexo, o leitor deve instalar e obter as ferramentas de
software e hardware apresentadas nesta seo. Todas as ferramentas de software so obtidas de
forma gratuita. O hardware obriga sua aquisio o que representa sempre algum custo.
952
D.2.1 ModelSim
A realizao das simulaes requer o uso do ModelSim PE Student Edition 10.4a. Esta
ferramenta disponibilizada gratuitamente pela Mentor Graphics. O ficheiro de instalao tem
um tamanho de aproximadamente 250 MB. Sendo que a instalao requer cerca de 600 MB.
Comeamos por visitar o site em
http://www.mentor.com/company/higher_ed/modelsim-student-edition
No momento de escrita deste anexo a verso mais recente do ModelSim disponvel a 10.4a.
Para fazer download clicamos em
Ser convidado a descarregar o ficheiro atravs da caixa de

dilogo da Figura D.10. Selecione a opo Guardar Ficheiro.
Figura D.10 Guarde o ficheiro de instalao

Execute o programa de instalao. questo se permite que o software efetue alteraes no
seu computador responda afirmativamente. Deve tambm aceitar os termos e as condies da
utilizao associados. O software deve ser instalado no folder por defeito
C:\Modeltech_pe_edu_10.4a. Siga os passos normais do processo de instalao.
953
No final do processo de instalao ser aberta uma folha de registo online como a que se apresenta
na Figura D.11. Preencha corretamente estes campos. Certifique-se que o seu e-mail est correto, j
que o ficheiro da licena ser enviado por e-mail. No final do processo ser dada uma confirmao
do envio do e-mail que contm tambm as indicaes a seguir para ativar a licena tal como se
representa na Figura D.12. Repare que a licena apenas vlida por um perodo de 180 dias. Aps o
que deve instalar nova verso e requerer nova licena.
Figura D.11 Pedido da licena para a edio estudante do ModelSim
954
Figura D.12 Instrues a seguir na ativao da licena para a edio estudante do ModelSim
O ModelSim fica agora apto a ser utilizado. Aps o a arranque ser exibida a janela apresentada
na Figura D.14. Ao longo deste anexo sero dadas as indicaes necessrias utilizao desta
ferramenta. Mas o leitor pode encontrar toda a informao que necessita nos vrios documentos
disponveis na ajuda.
No final ser criado um atalho no ambiente de trabalho como o da Figura D.13. Figura D.13 Atalho para o ModelSim
955
.
Figura D.14 ModelSim com a janela Help aberta
D.2.2 Xilinx Vivado para a NEXYS4 DDR FPGA
Para programar a Nexys4 DDR ser utilizado o Xilinx Vivado 2.015.1, que est disponvel
gratuitamente a partir da Xilinx Inc. A instalao ser realizada num computador com o sistema
operacional Windows 7 de 64 bits. (Note que o Xilinx Vivado tambm est disponvel para o sistema
operacional Linux). O arquivo de instalao tem aproximadamente 50 MB, enquanto que o aplicativo
requer cerca de 7 GB. Para obter o ficheiro de instalao (tamanho aproximado de 50MB) o leitor
dever visitar o site
http://www.xilinx.com/support/download.html
956
Certifique-se que seleciona a verso 2015.1 do Xilinx Vivado como indicado na Figura D.15. Localize
na pgina a Instalao do Vivado 2015.1 para Windows 64-bits como se representa na Figura D.16.
Figura D.16 Instalao do Vivado

2015.1 para Windows 64-bits
Figura D.15 Pgina de download do Vivado da Xilinx

A pgina de download ir requerer a autenticao numa conta da Xilinx. Se a no possuir dever
criar uma. Utilizando as credenciais recebidas pode ento efetuar o login. Agora, ser efetuada a
questo de se deseja salvar o executvel de instalao. Salve o arquivo num local temporrio.
Execute o instalador do Xilinx Vivado para iniciar o processo de instalao. Ser solicitado o seu ID
Xilinx de usurio e senha obtidos aquando do registo. Aceite as condies de utilizao. Instale a
verso Vivado WebPACK Edition. Certifique-se de que instala as Design Tools e o suporte para o Device
Artix-7. Esta a FPGA na Nesyx4 DDR. Se o desejar pode instalar outros dispositivos. Certifique-se de que
tem uma configurao de instalao idntica da Figura D.17. Aceite o folder de instalao por defeito
C:\Xilinx. Antes que a instalao tenha incio ser apresentado um quadro resumo como o ilustrado na
Figura D.18.
957
Figura D.17 Ferramentas de projeto e dispositivos
Figura D.18 Resumo da instalao
958
A janela Vivado License Manager permite obter a licena para o produto que acabou de instalar.
Selecione o Get Free Licenses. Ser efetuada uma ligao web ao site da Xilinx e no qual deve utilizar as
suas credenciais de acesso. Escolha a licena para Vivado WebPACK e selecione a Activate Node-Locked
License. Se o processo de licenciamento decorrer corretamente ser apresentada uma janela
comunicando que a licena foi corretamente gerada e que lhe foi enviada por e-mail. Se a ativao da
licena no ocorrer automaticamente utilize o e-mail que lhe foi enviado e siga as instrues a fornecidas.
Figura D.19 Vivado 2015.1
No seu ambiente de trabalho ser criado um cone como o que se representa na Figura D.19
D.2.3 Produo de Software com o Codescape

A produo de programas a executar no MIPSfpga feita utilizando o OpenOCD e o Codescape
MIPS SDK Essentials. A instalao do OpenOCD/Codescape pode ser realizada utilizando dois mtodos
diferentes: (1) utilizando o instalador fornecido no MIPSfpga Getting Started no folder Codescape; ou (2)
visitando o site da Imagination University Programme, e na seo Teaching Resources fazendo download
do OpenOCD/Codescape (offline installer).
Ao executar o instalador garanta que leciona a instalao de ambos: OpenOCD e Codescape MIPS
SDK, como se representa na Figura D.20. Garanta que mantm o folder de instalao por defeito para
que os scripts fornecidos no MIPSfpga Getting Started Guide possam funcionar corretamente.
Depois de indicar que aceita as condies legais de utilizao, na caixa de instalao Development
Type escolha a opo Both Linux and Bare Metal Applications. Na caixa de instalao Setup escolha os
Development Cores tipo MIPS Classic Legacy CPU IP Cores e MIPS Aptiv Family CPU IP Cores.
O Codescape ser instalado no folder C:\Program Files\Imagination Technologies. No final da

instalao ser permitido o acesso ao guia Display Codescape's getting started. Se no estiver interessado
nesta informao feche a pgina.
O manual online do OpenOCD est disponvel para sua referncia em

http://openocd.sourceforge.net/doc/html/index.html
959
O guia do usurio do OpenOCD est disponvel no ficheiro OpenOCD Users Guide.pdf, no folder
C:\Program Files\Imagination Technologies\OpenOCD\openocd-0.9.2
Figura D.20 Instalao do OpenOCD e do Codescape MIPS SDK

D.2.4 NEXYS4 DDR FPGA
O processador MIPSfpga foi desenvolvido para ser utilizado com uma FPGA criando um
processador soft core capaz de executar aplicaes de software. Para alm da Nexys4 DDR existem
outras placas para nas quais a implementao do processador MIPSfpga est preparada e com as
quais pode funcionar: Basys3; DE0; e DE2_115. Para alm disso existe informao de como preparar
verses de migrao para outras boards com FPGA no MIPSfpga Getting Started Guide.
960
Principais caractersticas da Nexys4

DDR
Figura D.21 Nexys4 DDR
961
A Nexys4 DDR disponibilizada pela Digilent (https://reference.digilentinc.com). De notar que

esta ferramenta de hardware pode ser adquirida a um custo reduzido quando destinada a ser
utilizada pela academia. Para saber como beneficiar desta poltica contate a empresa ou um seu
representante.
A Nexys4 uma plataforma completa pronta a ser utilizada no desenvolvimento de circuitos
digitais com base na FPGA Artix-7 da Xilinx. Com a sua FPGA de grande capacidade, memrias
externas de grande capacidade, USB, Ethernet e outros portos, a Nexys4 pode hospedar projetos
que variam desde os circuitos combinatrios introdutrios at aos processadores embutidos.
Vrios perifricos embutidos, incluindo um acelermetro, sensor de temperatura, microfone digital
MEMS, um amplificador de altifalante e uma srie de dispositivos de I/O permitem que a Nexys4
possa ser utilizada para explorar a utilizao da arquitetura MIPS em aplicaes do mundo real.
D.2.5Bus-Blaster V3c para o MIPS
O Bus-Blaster V3c para MIPS um econmico adaptador de alta velocidade para depurao
projetado para suportar a depurao via JTAG para vrios dos processadores MIPS. Esta verso do
Bus-Blaster tem um conector alvo de 14 pinos e cabo de interface com a lgica de buffer adequada
para targets EJTAG MIPS. Este dispositivo entregue com um Bus-Blaster v3c EJTAG para MIPS e
um adaptador JTAG de 14 para 6 pinos.
Para a depurao de software em hardware MIPS, recomenda-se o uso do Bus-Blaster com
o OpenOCD JTAG programming and debugging software que pode ser descarregado do Source
Forge.
Para instalar os drivers para o programador Bus-Blaster certifique-se de que instalou primeiro
as ferramentas Codescape SDK e OpenOCD de programao corretamente. Ao ligar o programador
ao computador atravs do cabo USB a luz de alimentao amarela (PWR) deve ficar acesa.
Abra uma consola de comando Windows em C:\Program Files\Imagination
Technologies\OpenOCD. Execute o aplicativo zadig_2.1.1.exe. Ser solicitado para permitir que o
Figura D.22 Bus-Blaster V3c para programa possa fazer alteraes no seu computador: clique em Sim. Na janela que se abre em
MIPS
962
seguida, clique em Options List All Devices, isto permite reduzir a lista para os itens que nos
interessa.
Selecione BUSBLASTERv3c (Interface 0) e em seguida clique em Install Driver. Este processo pode
demorar alguns minutos. Depois que o driver estiver instalado, uma janela pop-up surgir informando
que "O driver foi instalado com sucesso". Clique em Fechar. Tambm deve instalar o driver para
BUSBLASTERv3c (Interface 1). Quando tudo estiver concludo, feche a janela Zadig.
D.3 SIMULAO COM O MODELSIM

Uma forma econmica e eficiente de explorar o processador MIPSfpga atravs da realizao de
simulaes. Para isso vamos considerar duas aes distintas: (1) como simular o funcionamento do
processador MIPSfpga a executar um programa e (2) como modificar o programa a simular.
D.3.1 Simular a Execuo de um Programa no Processador MIPFSfpga
A simulao faz o pr-carreamento do processador MIPSfpga com o programa IncrementLEDs.
Este programa ilustrado no exemplo da Figura D.23. So apresentados o cdigo C e assembly
correspondentes. Uma anlise permite verificar que o contedo do endereo de memria
0xbf800000 repetidamente incrementado.
Para cada uma das instrues que constituem o programa, so abaixo fornecidos o cdigo mquina
e o respectivo endereo da instruo:
Cdigo Mquina Endereo de Instruo Cdigo Assembly
24090001 bfc00000: addiu $9, $0, 1 # val = 1

3c08bf80 bfc00004: lui $8, 0xbf80 # $8=0xbf800000
ad090000 bfc00008: L1: sw $9, 0($8) # mem[0xbf800000] = val
25290001 bfc0000c: addiu $9, $9, 1 # val = val+1
1000fffd bfc00010: beqz $0, L1 # branch to L1
00000000 bfc00014: nop # branch delay slot
O programa carregado na memria tendo incio no

endereo virtual 0xbfc00000.
963
// C # Cdigo assembly MIPS
# $9 = val, $8 = mem address 0xbf800000

unsigned int val = 1; addiu $9, $0, 1 # val = 1
volatile unsigned int* dest; lui $8, 0xbf80 # $8=0xbf800000
dest = 0xbf800000; L1: sw $9, 0($8) # mem[0xbf800000] = val
addiu $9, $9, 1 # val = val+1
while (1) { beqz $0, L1 # branch to L1
*dest = val; nop # branch delay slot
val = val + 1;
}
Figura D.23 Programa IncrementLEDs em C e assembler
Os endereos virtuais com incio em 0xa0000000 so mapeados para o endereo fsico 0x00000000.
A simulao mostra os sinais de interface de barramento AHB-Lite, que trabalham com endereos
fsicos. Assim, na forma de onda da simulao, o endereo de instruo 0xbfc00000 vai aparecer
como 0x1fc00000; 0xbf800000 como 0x1f800000; etc.
Carregamento do Projeto no ModelSim
O exemplo simulado nesta seo disponibilizado no folder MIPSfpga\ModelSim. Comece por fazer
uma cpia de salvaguarda do folder Project1, dando-lhe a designao de Project2. Aps ter iniciado o
ModelSim, carregue o projeto atravs da opo File -> Open, e procure o folder
MIPSfpga\ModelSim\Project2. Para isso ter que escolher o tipo de ficheiro *.mpf (Project File) e
visualizar o ficheiro mipsfpga_sim.mpf. Abra esse ficheiro.
Execuo do Script
Em seguida execute o script simMIPSfpga.tcl. Para isso deve escrever no painel Transcript
source simMIPSfpga.tcl
Este script realiza trs operaes diferentes:
Compila os ficheiros Verilog localizados em MIPSfpga\rtl_up
964
Adiciona sinais ao painel de visualizao de forma de ondas Wave

Simula o processador a executar o programa IncrementLEDs usando o mdulo testbench.v.
A execuo do script ir demorar alguns minutos. Ir receber o aviso:
Warning: Design size of 12114 statements or 2473 leaf instances exceeds ModelSim PE Student
Edition recommended capacity.
# Expect performance to be quite adversely affected.
Figura D.24 ModelSim no final da execuo do script
965
Por estarmos a utilizar a verso educacional, o desempenho ir ser penalizado pelo facto do nmero
de linhas de cdigo ultrapassar as 10k. No final, o prompt no painel Transcript apresentado ser (VSIM
2>) tal como se apresenta na Figura D.24.
Visualizao das Sadas
Se selecionar o painel Wave ter acesso s ferramentas para realizar a gesto

da visualizao dos sinais gerados. Utilize a ferramenta para visualizar a forma de onda inteira.
Acrescente um novo curso utilizando as ferramentas . Posicione o Cursor 1 em 1350000 ps e o
Cursor 2 em 950000 ps, faa zoom entre os cursores utilizando a ferramenta . Observamos na Figura
D.25 que o sinal SI_Reset_N mantido no nvel lgico LOW, mantendo o processador no estado de reset.
Em torno do instante 1 microssegundo, o sinal SI_Reset_N transita de LOW para HIGH e permite o
arranque do processador MIPSfpga. Como podemos observar, as linhas de endereo apresentam o valor
0x1fc00000, valor do endereo fsico que corresponde ao endereo virtual 0xbfc00000. Um ciclo de
relgio depois, o valor 0x2490001 lido da memria. A linha HWRITE est a LOW no decorrer da fase de
endereo, o que corresponde a uma leitura do barramento, veja a Figura D.9. Este cdigo de mquina
corresponde instruo addiu $9, $0, 1. Quatro ciclos de relgio mais tarde, a prxima instruo
obtida a partir do endereo 0x1fc00004 (HRADDR). O cdigo mquina 0x3c08bf80, que corresponde
instruo lui US $ 8, 0xbf80, aparece no barramento de leitura de dados (HRDATA).
966
Figura D.25 Visualizao dos sinais no arranque do processador MIPSfpga

Note-se que uma nova instruo obtida a cada 5 ciclos de relgio, em vez de a cada ciclo de relgio,
porque, logo aps o reset, as caches ainda no esto inicializadas. Especificamente, os 5 ciclos
necessrios, para obter uma instruo so os seguintes:
1 ciclo para o processador reconhecer que os dados/instruo no est na cache
1 ciclo para enviar o pedido para a Bus Interface Unit (BIU)
1 ciclo para a BIU colocar o pedido de leitura no barramento AHB-Lite.
1 ciclo para os dados serem devolvidos da memria externa para o barramento AHB-Lite.
1 ciclo para o processador colocar os dados de leitura/instruo num registrador
O processador continua a obter instrues. A instruo de armazenamento de palavra (sw $9,

0($8)), a que corresponde o cdigo de mquina 0xad090000, est localizada no endereo fsico
0x1fc00008. Esta instruo vai escrever no endereo 0xbf800000 (endereo fsico 0x1f800000). Note-
se que a prxima instruo (addiu $9, $9, 1), a que corresponde o cdigo de mquina
0x25290001 obtida do endereo 0x1fc0000c antes que a gravao da palavra na memria ocorra.
Logo aps que a instruo addiu (com cdigo mquina 0x25290001) aparece no HRDATA, o endereo
967
(HADDR) muda para 0x1f800000, o endereo a ser escrito pela inicial instruo de armazenamento
de palavra (sw) e por isso o HWRITE colocado a HIGH, como mostrado na Figura D.26. A gravao
na memria completada um ciclo mais tarde com o HWDATA a tomar o valor a ser escrito (neste
caso o valor 1). Em seguida, o processador obtm as instrues de branch e nop, com os cdigos
mquina 0x1000fffd e 0x00000000, e localizadas nos endereos fsicos 0x1fc00010 e 0x1fc00014,
respectivamente, regressando depois instruo sw no endereo 0x1fc00008. O leitor pode seguir
as formas de onda de como ele volta, repetidamente, a obter instrues nos endereos de memria
0x1fc00008 a 0x1fc00014 e escreve os valores incrementados no endereo de memria 0x1f800000.
Para observa o processo descrito anteriormente deve posicione o Cursor 1 em 1250000 ps e o
Cursor 2 em 1400000 ps, faa zoom entre os cursores.
Figura D.26 Visualizao do ciclo de incremento da memria
968
D.3.2 Modificar o Programa a ser Simulado

O ncleo MIPSfpga pode tanto escrever como ler da memria de I/O mapeada nas placas FPGA.
A Figura D.27mostra o cdigo C e assembly MIPS para o programa Switches&LEDs. Este programa l
os interruptores e os botes de presso na placa FPGA e reflete os seus valores para os LED vermelho
e verde, respectivamente. (Nota: a placa Nexys4 DDR no exibir os valores de botes quando
executar este programa porque ela no tem os LED verdes.)
// C # Cdigo assembly MIPS

unsigned int sw, pb;
unsigned int* ledr_ptr; # $10 = sw, $11 = pb
unsigned int* ledg_ptr; lui $8, 0xbf80
unsigned int* sw_ptr; addiu $12, $8, 4 # $12 = LEDG addr
unsigned int* pb_ptr; addiu $13, $8, 8 # $13 = SW addr
addiu $14, $8, 0xc # $14 = PB addr
ledr_ptr = 0xbf800000; readIO:
ledg_ptr = 0xbf800004; lw $10, 0($13) # sw = SW values
sw_ptr = 0xbf800008; lw $11, 0($14) # pb = PB values
pb_ptr = 0xbf80000c; sw $10, 0($8) # store sw to LEDR
sw $11, 0($12) # store pb to LEDG
while (1) { beq $0, $0, readIO # repeat
sw = *sw_ptr; nop # branch delay slot
pb = *pb_ptr;
*ledr_ptr = sw;
*ledg_ptr = pb;
}
Figura D.27 Programa Switches&LEDs
Nas quatro primeiras instrues assembly MIPS, o cdigo coloca os endereos de memria
mapeada para os LED vermelhos e verdes e os interruptores e botes de presso nos registros $8,
$12, $13 e $14. Nas duas prximas instrues LW (carga de palavra), o programa assembly l os
valores dos interruptores e dos botes de presso (nos registros $10 e $11). Finalmente, nas duas
969
instrues a seguir sw (armazenamento de palavra), o cdigo escreve esses valores para os LED
vermelhos e verdes. O loop, em seguida, repete usando a instruo beq (branch se igual). O branch
sempre executado porque $0 sempre igual a si prprio.
O contedo do arquivo ram_reset_init.txt com o cdigo de mquina para o programa
Switches&LEDs mostrado em baixo. Este arquivo est localizado em MIPSfpga\rtl_up\ initfiles\
3_Switches&LEDs.
Cdigo Mquina Endereo de Instruo Cdigo Assembly
3c08bf80 bfc00000 lui $8, 0xbf80 #$8=LEDR addr

250c0004 bfc00004 addiu $12, $8, 4 #$12=LEDG addr
250d0008 bfc00008 addiu $13, $8, 8 #$13=SW addr
250e000c bfc0000c addiu $14, $8, 0xc #$14=PB addr
8daa0000 bfc00010 readIO: lw $10, 0($13) #$10=SW
8dcb0000 bfc00014 lw $11, 0($14) #$11=PB
ad0a0000 bfc00018 sw $10, 0($8) #SW->LEDR
ad8b0000 bfc0001c sw $11, 0($12) #PB->LEDG
1000fffb bfc00020 beq $0, $0, readIO #repeat
00000000 bfc00024 nop #branch delay slot
Para modificar o programa IncrementLEDs executado pelo processador MIPSfpga apenas tem
que copiar o arquivo ram_reset_init.txt correspondente ao programa Switches&LEDs, que se localiza
em MIPSfpga\rtl_up\initfiles\3_Switches&LEDs\, para o folder MIPSfpga\ModelSim\Project2. Esta
operao ir substituir o ficheiro existente com o mesmo nome.
Para reinicializar a simulao e obrigar leitura do ficheiro de reinicializao da memria como o novo
programa Switches&LEDs, escreva no painel Transcript
restart f
Adicione agora ao painel Wave os sinais a visualizar: IO_Switch, IO_PB, IO_LEDR, and IO_LEDG. Para
isso, apenas ter que os selecionar no painel Objects e arrastar para o painel Wave.
Especifique os valores das entradas: IO_Switch (18-bits) e IO_PB (5-bits). Para isso no painel
Transcript escreva
970
force IO_Switch 18'h3f58c

force IO_PB 5'h1a
Estamos agora em condies de executar a simulao. Para isso, no painel Transcript, escreva
run 2000
Este comando vai ordenar a simular a execuo do programa por 2000000 ps. Como se pode
observar Figura D.28 os LED passam a refletir o estado das respectivas entradas. Primeiro o IO_LED_R
(~1514971 ps) e depois o IO_LED_G (~1545030 ps).
Pode repetir este comando em conjunto com o comando force para observar os estados dos LED
a serem modificados.
Figura D.28 Alterao do estado dos LED
971
D.4 CARREGAR E DEPURAR UM PROGRAMA EM TEMPO REAL

Esta seo ir descrever os passos a seguir para que se possa observar o processador MIPSfpga a
executar em tempo real um programa escrito em C. Para que isso seja possvel necessrio realizar
um conjunto de tarefas que so descritas a seguir. Ao contrrio da Seo D.3, esta seo obriga a
dispor de hardware especfico e que j foi descrito na Sees D.2.4 e D.2.5.
Vamos utilizar o OpenOCD e o Bus-Blaster para carregar na placa Nexys4 DDR o programa a ser
executado pelo processador MIPSfpga. O OpenOCD usa o gdb de Codescape, um depurador de
consola, para transferir e depurar programas a executar no ncleo MIPSfpga utilizando um
programador EJTAG. Essencialmente, OpenOCD uma ponte de software entre o gdb e o
programador. O OpenOCD tambm tem vrios comandos especficos do ncleo que podem ser
acedidos a partir do gdb atravs do comando do gdb 'Monitor'.
At agora, temos vindo a executar a simulao de programas no processador MIPSfpga no
inicializado. Embora esta situao seja aceitvel para programas simples, para programas que usam
armazenamento em cache e outros recursos avanados, o ncleo deve ser inicializado usando o
cdigo de inicializao. Depois de ter terminado a inicializao do processador, o cdigo de
inicializao salta para a funo principal do cdigo do usurio para executar o seu programa.
O cdigo de inicializao MIPSfpga fornecido inicializa o ncleo MIPSfpga atravs da criao de
registros e inicializando as caches e o TLB. O cdigo de inicializao est localizado no endereo virtual
0xbfc00000, que o endereo da exceo do reset. Aps a reinicializao, o ncleo MIPSfpga comea
a obter as instrues deste endereo (endereo virtual 0xbfc00000 que corresponde ao endereo
fsico 0x1fc00000.) Apesar de uma profunda compreenso no ser essencial para a execuo de
cdigo no processador MIPSfpga, o utilizador interessado pode encontrar o cdigo de inicializao no
folder MIPSfpga\Codescape\ExamplePrograms\CExample. O cdigo de inicializao deixa o ncleo
MIPSfpga pronto para executar o cdigo do usurio inicializando:
Co-processador 0
O TLB
A cache de instruo
972
A cache de dados
Aps inicializar o processador, o cdigo de inicializao chama a funo _start, que executa
inicializaes adicionais e, em seguida, chama a funo main do usurio.
D.4.1 Escrever e Compilar um Programa em C com o Codescape
Cdigo Fonte do Programa
Vamos exemplificar como pode um programa escrito em C ser compilado utilizando o Codescape
e os scripts fornecidos com o MIPSfpga. O programa tem trs modos de funcionamento,
correspondentes aos botes de presso, assim como um Modo Padro. Quando boto 3
pressionado (btnD), o programa exibe os valores incrementados nos LED. Quando o boto 2
pressionado (btnL), os LED mostram valores decrementados. Quando tecla 1 for pressionada (btnC),
os LEDs piscam. Quando nenhum boto for pressionado, os LED mostram um grupo de 4 LED a serem
repetidamente deslocados para a esquerda. Para alm das construes tpicas C, o cdigo tambm
demonstra como incluir inline assembly.
De notar que todas as variveis associadas com o hardware so declaradas como volatile.
Desta forma impede-se que sejam removidas por otimizao do compilador.
// C
#define inline_assembly() asm("ori $0, $0, 0x1234")

void delay();
int main() {
volatile int *IO_LEDR = (int*)0xbf800000;
volatile int *IO_PUSHBUTTONS = (int*)0xbf80000c;
volatile unsigned int pushbutton, count = 0;
while (1) {
pushbutton = *IO_PUSHBUTTONS;
973
switch (pushbutton) {
case 0x8:
count++;
break;
case 0x4:
count--;
break;
case 0x2:
if (count==0)
count = ~count;
else
count = 0;
break;
default:
if (count==0)
count = 0xf;
else
count = count << 1;
}
*IO_LEDR = count; // Escreve para os LED vermelhos

delay();
inline_assembly();
}
return 0;
}
Figura D.29 Cdigo exemplo em C

Compilar o Programa
Para compilar este programa C, primeiro abra uma consola de comando Windows utilizando o
comando cmd.exe a partir do menu Iniciar do Windows. Dirija o prompt para a pasta
MIPSfpa\Codescape\ExamplePrograms\ CExample e escreva na consola
make
974
Isto ir compilar o programa C usando o Makefile (localizado na pasta C exemplo) e o gcc do

Codescape.
O Makefile gera o arquivo FPGA_Ram.elf, que um ficheiro ELF (Executable and Linkable Format)
executvel. Este arquivo usado pelo gdb do Codescape para carregar o programa no processador
MIPSfpga atravs do programador EJTAG. O leitor pode tambm estar interessado em ver o ficheiro
FPGA_Ram_dasm.txt que mostra o executvel disassemblado intercalado com o cdigo-fonte C. O
topo deste arquivo lista o cdigo de inicializao, a partir do endereo virtual 0x9fc00000.
O endereo virtual 0x9fc00000 correspondente ao endereo fsico 0xbfc00000, ou seja,
0x1fc00000. Assim, a instruo em 0x9fc00000 ser obtida aps o reset. A diferena que
0x9fc00000+ est no kseg0 e possui cache, 0xbfc00000+ est no kseg1 e no possui cache. Colocar o
cdigo em 0x9fc00000+ permite que o cdigo de inicializao execute mais rpido depois que a cache
seja habilitada. A parte inferior do arquivo (procure por "main.c") mostra o cdigo do utilizador, com
incio no endereo virtual 0x8000075c.
O arquivo FPGA_Ram_modelsim.txt, tambm localizada na pasta CExample, mostra uma verso
legvel do executvel (endereos de memria com cdigo de mquina e cdigo assembly) sem a fonte
de C.
O leitor pode remover todos os arquivos criados durante a compilao digitando no prompt de
comando
make clean
975
D.4.2 Carregar o Processador MIPSfpga na Nexys4

Seguindo as instrues fornecidas nesta seo ir instalar o processador MIPSfpga na FPGA Artix-
7 da Xilinx, presente na placa Nexys4 DDR, usando software Xilinx Vivado.
Figura D.30 Instalao experimental

Ligar e Alimentar a Nexys4 DDR
Ligue o seu computador atravs do cabo de programao USB porta "programador USB" da placa
Nexys4 DDR identificado na Figura D.21. Agora comute o interruptor de alimentao da placa para a
posio ON. Se a placa est configurada de fbrica, ser executado um programa pr-carregado que
escreve aos 7 segmentos exibe com um padro de cobra que se repete indefinidamente. Certifique-
976
se de que a placa est configurada num dos Modos JTAG ou QSPI: isto , o jumper de Modo deve ligar
os dois pinos do centro ou, como mostrado na figura, os dois mais esquerda.
Instalar o Processador MIPSfpga
Abra a sua instalao do Xilinx Vivado. Ser-lhe- apresentada uma janela como a que se ilustra na
Figura D.31. Selecione a opo Flow Open Hardware Manager.
Figura D.31 Incio do Xilinx Vivado

A janela Hardware Manager ser aberta como se ilustra na Figura D.32. Clique em Open Target e
escolha Auto Connect. Aviso: quando clicar em Auto Connect, o Xilinx Vivado pode parecer travar. Ele
est se conectando ao alvo - o que ir demorar alguns segundos enquanto o Vivado detecta a FPGA na
placa Nexys4 DDR.
977
Figura D.32 Hardware Manager

Agora, clique em Program device e selecione xc7a100t_0 como mostrado na Figura D.33.
Figura D.33 Programao do MIPSfpga
978
A janela Program Device ser aberta, como mostrado na Figura D.34. Na caixa arquivo de
Bitstream, procure: MIPSfpga/Nexys4_DDR/mipsfpga_nexys4_ddr.bit. Deixe a caixa Debug Probe File
em branco e a opo Enable End of Startup Check selecionada. Clique em Program.
Figura D.34 Program Device

Executar o Processador MIPSfpga
Agora o leitor est pronto para executar o processador MIPSfpga na FPGA Artix-7 da placa Nexys4
DDR. Pressione o boto de RESET (rotulado CPU RESET, consulte a Figura D.21) para provocar o reset
do processador. Aps soltar o boto Reset, o processador ir executar o programa
IncrementLEDsDelay, que gera um nmero crescente binrio usando os LED, comeando com 1. Os
LED alteram os valores a cada segundo.
D.4.3 Carregar o Programa via BUS-BLASTER
Nesta seo o leitor vai baixar um programa compilado no ncleo MIPSfpga usando a interface
EJTAG e o programador Bus-Blaster. O programador Bus-Blaster recebe uma entrada de cabo de alta
velocidade USB 2.0 e converte os comandos no protocolo de srie EJTAG que permite carregar
programas no ncleo MIPSfpga e controlar a depurao de programas em execuo no MIPSfpga.
Agora abra uma consola de comando Windows (ou seja, o menu Iniciar cmd.exe).
Na consola de comando, dirija o prompt para o diretrio
MIPSfpga\Codescape\ExamplePrograms\Scripts\Nexys4_DDR.
979
Agora, execute o script que carrega o novo programa (a partir do diretrio C Exemplo) no ncleo
MIPSfpga. Digite o seguinte no prompt de comando
loadMIPSfpga.bat ..\..\CExample
O script loadMIPSfpga.bat realiza as seguintes tarefas:

1. Compila o programa no diretrio especificado (usando make)
2. Executa OpenOCD numa nova consola
3. Executa o gdb (ou seja, MIPS-MTI-elf em GDB de Codescape) no ncleo MIPSfpga numa nova
consola.
4. Carrega o arquivo executvel (.elf) do diretrio especificado no ncleo MIPSfpga usando
OpenOCD e gdb.
Depois de executar o script, o leitor deve ver o programa em execuo no ncleo MIPSfpga. No
caso do programa CExample, ver os LED em rolagem para a esquerda. Pressione os botes para ver
os outros modos de funcionamento.
Qualquer programa pode ser carregado no processador MIPSfpga utilizando o programa de lote
com a indicao do caminho do programa a ser carregado.
loadMIPSfpga.bat <program directory>
Considerando que o ncleo foi previamente instalado na FPGA e que o Bus-Blaster est ligado
Nexys4 DDRR pode executar outros programas. No se esquea de fechar as consolas OpenOCD e
de comando gdb gerados pelo script de carregamento MIPSfpga.bat.
980
D.4.4 Executar a Depurao de Cdigo

Clique na consola gdb para selecionar esta ferramenta tal como se ilustra na Figura D.35
O gdb est ligado ao ncleo MIPSfpga usando OpenOCD. Tambm pode ver a consola OpenOCD se
estiver interessado e que se representa na Figura D.36. No final do script loadMIPSfpga.bat, o gdb
carrega o arquivo executvel (.elf) e inicia o programa executar no processador MIPSfpga. A seguir
so fornecidos alguns comandos teis para execuo e depurao de um programa que est sendo
executado em tempo real sobre no processador MIPSfpga usando o gdb.
Consulte tambm o manual do gdb disponvel nesta pgina
http://www.gnu.org/software/gdb/documentation/
Uma referncia rpida dos comandos mais comuns do gdb est disponvel em
C:\Programas\Imagination Technologies\Documentation\refcard.pdf.
Figura D.35 Consola do gdb
981
Figura D.36 Consola do OpenOCD

A ttulo de exemplo podemos ilustrar as potencialidades do gdb na depurao de cdigo.
Reset e Stop do Processador
Ao executar o comando abaixo o processador suspende a execuo do programa. Para alm de
provocar o reset do processador suspende tambm a sua execuo.
monitor reset halt -> provoca o reset e suspende a execuo
Colocar um Breakpoint
Ao associar um breakpoint a uma linha de comando sempre que o endereo dessa linha de
comando alcanado o processador suspende a execuo do programa.
982
b main -> Coloca um breakpoint na funo main. No nosso

cdigo de exemplo a funo main tem incio no
endereo 0x8000076c.
b *0x80000848 -> Coloca um breakpoint no endereo 0x80000848.No
cdigo de exemplo esta instruo corresponde
instruo sw que escreve nos LED vermelhos.
Informao dos Breakpoint

i b -> Lista informao sobre os breakpoint existentes.
Continuar a Execuo de um Programa

c -> Continua a execuo do programa. Ir suspender
se encontrar um breakpoint. No nosso caso o
primeiro a ser encontrado vai ser o que
corresponde funo main.
c -> Continua at ao prximo breakpoint. No nosso caso
corresponde ao do endereo *0x80000848
Imprimir o Contedo de uma Varivel

p count -> Apresenta o contedo da varivel count.
p/x count -> Apresenta o contedo da varivel count em
hexadecimal.
p/x &count -> Apresenta o endereo da varivel count em
hexadecimal.
Informao dos Valores dos Registros
i r -> Imprime o valor de todos os registros.
i r v1 -> Imprime o valor do registro v1 (valor a escrever
nos LED).
i r v0 -> Imprime o valor do registro v0 (endereo de
memria dos LED).
983
Execuo de uma Instruo

stepi -> Executa apenas uma instruo.
Apagar um Breakpoint
d 1 -> Apaga o breakpoint 1.
Executa o Programa
Monitor reset run -> Sem a existncia de breakpoints o programa
ser executado normalmente.
984
Leituras Futuras
Berlin L., The Man Behind the Microchip: Robert Noyce and the Invention of Silicon Valley, Oxford University Press, 2005.
A fascinante biografia de Robert Noyce, inventor do microchip e fundador da Fairchild e Intel. Para quem quiser trabalhar em Silicon Valley, este livro d
informaes sobre a cultura da regio, uma cultura influenciada mais fortemente por Noyce do que qualquer outro indivduo.
Colwell R., The Pentium Chronicles: The People, Passion, and Politics Behind Intels Landmark Chips, Wiley, 2005.
Conto de um insider do desenvolvimento de vrias geraes de chips Pentium da Intel, contada por um dos lderes do projeto. Para aqueles que consideram
uma carreira no campo, este livro oferece uma viso da gesto de grandes projetos de concepo e um olhar behind-the-scenes para uma das linhas de
microprocessadores comerciais mais significativas.
Ercegovac M., and Lang T., Digital Arithmetic, Morgan Kaufmann, 2003.
O mais completo texto sobre sistemas aritmticos computacionais. Um excelente recurso para a construo de unidades aritmticas de alta qualidade para
computadores.
Hennessy J., and Patterson D., Computer Architecture: A Quantitative Approach, 5th ed., Morgan Kaufmann, 2011.
Um texto fundamental sobre a arquitetura avanada de computadores. Se voc est intrigado sobre o funcionamento interno de microprocessadores de ltima
gerao, este o livro para voc.
Kidder T., The Soul of a New Machine, Back Bay Books, 1981.
A clssica histria de projeto de um sistema de computacional. Trs dcadas depois, a histria ainda um virar de pgina e os detalhes sobre a gesto de projeto
e a tecnologia ainda soam a verdadeiro.
Pedroni V., Circuit Design and Simulation with VHDL, 2nd ed., MIT Press, 2010.
Uma referncia que mostra como projetar circuitos com VHDL.
Ciletti M., Advanced Digital Design with the Verilog HDL, 2nd ed., Prentice Hall, 2010.
Uma boa referncia para Verilog 2005 (mas no SystemVerilog).
SystemVerilog IEEE Standard (IEEE STD 1800).
O padro IEEE para HDL Verilog; ltima atualizao em 2009. Disponvel em ieeexplore.ieee.org.
VHDL IEEE Standard (IEEE STD 1076).
O padro IEEE para VHDL; ltima atualizao em 2008. Disponvel a partir IEEE. Disponvel em ieeexplore.ieee.org.
Wakerly J., Digital Design: Principles and Practices, 4th ed., Prentice Hall, 2006.
Um texto abrangente e legvel em projeto digital, e um excelente livro de referncia.
Weste N., and Harris D., CMOS VLSI Design, 4th ed., Addison-Wesley, 2011.
O projeto Very Large Scale Integration (VLSI) a arte e a cincia de construir chips que contm grande quantidade de transistores. Este livro, coautoria de um
dos nossos escritores favoritos, atravessa este domnio desde o incio atravs das tcnicas mais avanadas utilizadas em produtos comerciais
985
.
986

Digital Design and Computer Architecture Portuguese Translation

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Digital Design and Computer Architecture Portuguese Translation

Diunggah oleh

Hak Cipta:

Format Tersedia

Projeto Digital e

Esta traduo Portuguesa foi patrocinada

Renato de Macedo Giovanini

Cursos Alvo e Projetos (Nvel de Escolaridade)

Organizao de Computares & Arquiteturas, Arquiteturas Avanadas de Computadores (Licenciatura, Mestrado)

Projeto SoC (MSc)

Verificao de Projeto (MSc)

Projeto de Sistemas Embarcados (Licenciatura, Mestrado)

Outros livros relevantes so referenciados aqui

Programa global de Workshops: a ser anunciado na pgina Eventos Universitrios.

Host PC: Windows 64 bits

Digilent Basys 3 ou Nexys 4 DDR, com Xilinx Artix 7 FPGA

Vivado (Xilinx) Web Pack Edition

Mentor Graphics ModelSim (Student ou Full editions) ou Xilinx Xsim

NOTA: Os pedidos podem ser rejeitados pelas seguintes razes

1.2. A ARTE DE GERIR A COMPLEXIDADE

Veja Elliott Coues, ed, a histria de Lewis

Figura 1.2 Espingarda Flintlock com

Charles Babbage, 1791-1871.

Frequentou a Universidade de Cambridge 1.3. ABSTRAO DIGITAL

Figura 1.3 Mquina Analtica de

Ao contrrio da mquina de Babbage, a maioria dos computadores electrnicos usa uma

1.4. BASES NUMRICAS

Figura 1.4 Representao de um

1.4.1. Nmeros Decimais

Exemplo 1.1 CONVERSO DE BINRIO PARA DECIMAL

Tabela 1.1 Nmeros binrios e o seu equivalente decimal

Figura 1.5 Converso de um nmero

Exemplo 1.2 CONVERSO DE DECIMAL PARA BINRIO

1.4.3. Nmeros Hexadecimais

chamada de hexadecimal. Os nmeros hexadecimais utilizam os dgitos de 0 a 9, juntamente com as

Figura 1.6 Converso de um nmero

Exemplo 1.4 CONVERSO DE BINRIO PARA HEXADECIMAL

Tabela 1.2 Sistema numrico hexadecimal

Exemplo 1.5 CONVERSO DE DECIMAL PARA HEXADECIMAL E BINRIO

Figura 1.7 Byte menos e mais significante

Exemplo 1.6 ESTIMAO DE UMA POTNCIA DE DOIS

1.4.5. Adio Binria

Exemplo 1.7 SOMA BINRIA

Exemplo 1.8 SOMA COM OVERFLOW

Exemplo 1.9 NMEROS DE SINAL/MAGNITUDE

Exemplo 1.10 REPRESENTAO DE UM NMERO NEGATIVO EM COMPLEMENTO-2

Exemplo 1.11 VALOR DE NMEROS NEGATIVOS EM COMPLEMENTO-2

Os nmeros em complemento-2 tm a vantagem de que a adio funciona corretamente tanto para

Exemplo 1.12 ADICIONAR DOIS NMEROS EM COMPLEMENTO-2

A subtrao realizada tomando o complemento-2 do segundo nmero seguida da adio.

Exemplo 1.13 SUBTRAIR DOIS NMEROS EM COMPLEMENTO-2

O complemento-2 de 0 encontrado invertendo todos os bits (produzindo 11 ... 111 2) e

Exemplo 1.14 ADICIONAR DOIS NMEROS EM COMPLEMENTO-2 COM OVERFLOW

Tabela 1.3 Intervalo de nmeros de N-bits

Figura 1.11 Linha numrica e codificao binria de 4-bits

1.5. PORTAS LGICAS

Figura 1.16 Mais portas de duas entradas

Figura 1.17 Porta XNOR

Figura 1.18 Tabela verdade XNOR

1.5.6. Portas de Mltiplas Entradas

Exemplo 1.17 PORTA AND DE QUATRO ENTRADAS

1.6. POR BAIXO DA ABSTRAO DIGITAL

Figura 1.23 Nveis lgicos e margens de rudo

Exemplo 1.18 DETERMINAR AS MARGENS DE RUDO

Figura 1.24 Circuito inversor

Figura 1.25 Caracterstica de transferncia DC e nveis lgicos

1.6.5. A Disciplina Esttica

Tabela 1.4 Famlias lgicas de nveis lgicos de 5 V e 3.3 V