Arquiteturadepc

PRESIDENTE DA REPBLICA
LUS INCIO LULA DA SILVA

MINISTRO DA EDUCAO
FERNANDO HADDAD
SECRETRIO DE EDUCAO PROFISSIONAL E TECNOLGICA
ELIEZER PACHECO
DIRETOR GERAL
FRANCISCO DAS CHAGAS DE MARIZ FERNANDES
DIRETOR DA UNIDADE SEDE
ENILSON ARAJO PEREIRA
DIRETOR DA UNED-MOSSOR
CLVIS COSTA DE ARAJO
DIRETOR DE ADMINISTRAO E PLANEJAMENTO
JUSCELINO CARDOSO DE MEDEIROS
DIRETOR DE ENSINO
BELCHIOR DE OLIVEIRA ROCHA
DIRETOR DE PESQUISA
JOS YVAN PEREIRA LEITE
DIRETOR DE RELAES EMPRESARIAIS E COMUNITRIAS
LIZNANDO FERNANDES DA COSTA
GERENTE DE DESENVOLVIMENTO DE RECURSOS HUMANOS
AURIDAN DANTAS DE ARAJO
COORDENADOR DA EDITORA
SAMIR CRISTINO DE SOUZA
Arquitetura de
Computadores
a viso do software
COMPUTADOR
RECEITAS
S
RE E T O
CEI R
TA
S
0
16
32
20
36
24
40
12
28
44
CONTROLE
S
TE E T O
MPE R
RO
S
VIA DE DADOS
64
80
52
68
84
0
1
2
3
4
PROCESSADOR
ENTRADA
48
56
72
88
60
76
92
SE
BO T O R
LO
S
SE
CA TO R
RNE
S
SADA
96
112
128
100
116
132
104
120
136
108
124
140
MEMRIA
Eduardo Brulio Wanderley Netto
http://www.cefetrn.br/~braulio/ACv1/
Arquitetura de Computadores: A viso do software

Copyright 2005 da Editora do CEFET-RN
Todos os direitos reservados
Nenhuma parte desta publicao poder ser reproduzida ou transmitida de
qualquer modo ou por qualquer outro meio, eletrnico ou mecnico, incluindo
fotocpia, gravao ou qualquer tipo de sistema de armazenamento e transmisso
de informao, sem prvia autorizao, por escrito, da Editora do CEFET-RN.
Diviso de servios Tcnicos
Catalogao da publicao na fonte.
Biblioteca Sebastio Fernandes (BSF) CEFET/RN
Wanderley Netto, Eduardo Brulio,
Arquitetura de Computadores: A viso do software/ Eduardo Brulio
Wanderley Netto Natal: Editora do CEFET-RN, 2005
Xii, 201p.: il.
ISBN 85 89571 06 8
Organizador: Francisco das Chagas Silva Souza.
1.
Arquitetura de computadores - Informtica. 2.
Organizao de computadores - Informtica . 3. Assembly Informtica . 4. Linguagem de montagem - Informtica . 5.
Linguagem de mquina - Informtica .I. Ttulo.
CDD 004.22
CEFET/RN/BSF
ARTE DA CAPA
Tnia Carvalho da Silva
Editora do CEFET-RN
Av. Sen. Salgado Filho, 1559, CEP 59015-000
Natal-RN. Fone: (0XX84) 4005-2668, 3215-2733
E-mail: dpeq@cefetrn.br
Prefcio
iii
Esther e Elker
minha Me e meu Pai (in memorian)
minha famlia
iv
Arquitetura de Computadores: a viso do software
Prefcio
Prefcio
1.1 Introduo
O termo arquitetura de computadores tem sua origem em um antigo
livro editado por Werner Buzhholz: Planning a Computer System: Project
Stretch de 1962 [1]. Frederick Brooks introduziu o termo no captulo
intitulado Architectural Philosophy. Em 1964 o projeto do system/360
tambm utilizou o termo, talvez com uma viso mais limitada. Quase duas
dcadas depois Jean-Loup Baer [2] revisita o termo e o define como um
conjunto de conhecimentos que fazem parte da Arquitetura de um
Computador: estrutura (modelagem esttica das partes); organizao
(interao dinmica das partes e o seu gerenciamento); implementao
(projeto fsico dos blocos construtivos especficos); e avaliao (o estudo do
comportamento do sistema e do seu desempenho, seja em parte ou no todo).
Modernamente, entende-se o termo como sendo a viso que um
programador deve ter da mquina quando o mesmo est utilizando uma
linguagem de montagem e/ou de mquina [3].
parte da discusso filosfica que envolve a definio do termo e do
emaranhado de vises - nem sempre alinhadas - sobre o que significa
Arquitetura de Computadores, procuramos manter o ttulo desta obra de
forma expandida contendo o que exatamente se espera do texto: a viso do
software sobre a mquina onde ele ir ser executado.
1.2 Motivao
A maioria do material didtico sobre o tema [4, 5, 6] costuma apresentar
detalhes de projeto em algum nvel de abstrao, muitas vezes com
caractersticas to prximas de uma implementao real (fsica) que os tornam
muito enfadonhos para cursos com nfase em desenvolvimento de software.
Alm disto, tais conhecimentos prescinde de requisitos curriculares em
vi
sistemas digitais, o que nem sempre est presente em cursos de graduao

curta, focados em seu saber especfico. Naturalmente, o material didtico
atual, carece de um ecletismo particular, pois tem um pblico abrangente:
desde cientistas da computao at engenheiros eletricistas (quando muito
alinhados com o tema), mas certamente tambm todos aqueles que, de alguma
forma, querem ou precisam conhecer a mquina que operam de forma mais
intelectual.
Neste contexto, um material especfico para cursos de graduao
tecnolgica com nfase em software, trar os temas mais relevantes da rea de
Arquitetura de Computadores luz sob este prisma, dando oportunidade para
uma abordagem mais precisa e aprofundada, sem onerar nem avolumar a obra
com materiais de interesse secundrio.
Neste contexto, o ttulo do livro tambm explicita seu pblico, sendo
este primordialmente formado por alunos que galgam as primeiras cadeiras de
cursos de graduao tecnolgica em desenvolvimento de software.
1.3 Abrangncia
Dentro da estrutura de cursos da Gerncia Educacional de Tecnologia
da Informao (GEINF), o primeiro destinatrio da obra so os alunos que
fazem o curso de Tecnologia em Desenvolvimento de Software. Em sua grade
atual a disciplina Organizao de Computadores tem os objetivos alinhados
com a estrutura proposta para este livro. Ainda no mbito da GEINF, os
cursos tcnicos de informtica podero adotar o material como auxiliar ou
como tpicos avanados dentro de disciplinas correlatas. Tambm o curso de
Tecnologia em Redes de Computadores (em fase de estudos, mas com
perspectivas para seu incio em 2006) poder fazer uso do material.
Dentro do CEFET-RN tambm as novas disciplinas do curso de
Automao podero utilizar a obra.
Cursos de tecnologia em Desenvolvimento de Software, da rede de
ensino tecnolgico, assim como o Curso Superior de Tecnologia em
Desenvolvimento de Aplicaes para Web, do CEFET-RJ e do UFTPR, o
curso de Tecnologia em Desenvolvimento de Software do CEFET-PB e o
curso de Tecnologia em Sistemas de Informao do CEFET-PE, so exemplos
de cursos que podero utilizar em carter efetivo o presente material. Afora os
demais cursos correlatos que poderiam adotar o livro como cursos de
Automao Industrial, Sistemas Distribudos, etc. embora no seja o foco do
trabalho.
Prefcio
1.4 Aspectos Pedaggicos

Existe um certo consenso na comunidade cientfica que a utilizao de
ferramentas computacionais de auxlio ao ensino produz um efeito positivo na
aprendizagem do aluno. Especificamente, em Arquitetura de Computadores,
alguns experimentos foram feitos e publicados [7, 8, 9]. H divergncias sobre
quais ferramentas utilizar - comerciais ou didticas - mas todos concordam
que o auxlio imprescindvel ao ensino moderno.
Os livros atuais costumam apresentar um material auxiliar para o aluno
explorar (simuladores, sintetizados, etc), mas raramente incentivam o seu uso
corriqueiro. Este livro apresenta um conjunto de ferramentas desenvolvidas no
NUARQ, dentro do projeto Visual Architecture VA, com vistas ao ensino da
disciplina. Desta forma, acreditamos envolver fortemente a pesquisa com o
ensino, fortalecendo o seu elo de ligao, to importante na conjuntura atual.
As ferramentas de simulao podem ser encontradas no site do livro:
http://www.cefetrn.br/~braulio/ACv1/
1.5 MIPS
O MIPS o processador alvo de nosso livro. Ele foi escolhido por fazer
parte de um gnero de processadores simples, mas muito eficientes. A
simplicidade nos permite aprofundar os conceitos sem torn-los ininteligveis.
Existem duas famlias de arquiteturas MIPS na nomenclatura atual: MIPS32 e
MIPS64. H tambm extenses como MIPS16 e outras. Vamos trabalhar com
um subconjunto da arquitetura MIPS32, o que nos permitir produzir
pequenos softwares para execuo em simuladores.
1.6 Agradecimentos
Escrever um livro didtico tentar aprisionar nas palavras o
conhecimento. Isto requer um esforo de concentrao muito grande e,
portanto, uma devoo exclusiva obra em andamento. Esta dedicao s me
foi possvel pela compreenso da importncia deste trabalho por minha esposa
e por minha filha. No fora estas protagonistas, um manuscrito incompleto
estaria ainda por aparecer. Meus primeiros agradecimentos, depois do Deus
Pai, que nos permitiu tamanha travessura e ousadia, so para estas mulheres de
minha vida. No posso deixar de estender tambm aos meus familiares tal
atitude de compreenso.
vii
viii
Em um outro flanco esto os alunos do Ncleo de Pesquisas em

Arquiteturas de Computadores do CEFET-RN. Eles foram instigados a
encontrar respostas desde cedo para problemas muito maiores que seus
conhecimentos. Mas, ao final chegaram com trabalhos que muitas vezes me
surpreenderam, bem como ao meu colega Prof. Jorgiano, do mesmo grupo,
pelos resultados positivos alcanados.
Por fim, como a arte tambm precisa de sorte, ou como diria dentro de
minha religiosidade, da mo de Deus, gostaria de agradecer aos meus alunos
da disciplina de organizao de computadores, em especial a turma 1.71.1V de
2005.2, que foram os primeiros a observar o material e apontaram diversos
erros nos manuscritos. Esta turma certamente uma das mais dedicadas que j
pude ter o prazer de interagir.
Meus pais so figuras que transcendem aos agradecimentos, tudo me
deram, dentro de suas limitaes, e no mediram esforos para minha
formao. Poderia faltar qualquer coisa dentro de casa, mas nunca faltou o
amor e a dedicao deles para comigo e com meu irmo. No o material que
faz o homem, mas o que ele ganha de valores em um mundo cada vez mais
guiado pelo financeiro. A eles minha homenagem, no meu agradecimento!
Eduardo B. Wanderley Netto
Natal/RN, dezembro de 2005
1.7 Bibliografia Especfica

[1] Werner Buzhholz, Planning a Computer System: Project Stretch , 1962
[2] Jean-Loup Baer, Computer Systems Architecture, 1980
[3] Gerrit Blaauw, Frederick Brooks, Computer Architecture: concepts and evolution,
1997
[4] Paterson & Henessy, Computer Organization and Design, 3ed., 2004
[5] Tanenbaum, Structured Computer Organization, 4 ed., 1998
[6] Willian Stalling, Arquitetura e Organizao de Computadores, 5ed. 1997
[7] Ney Calazans and Fernando Moraes, Integrating the teaching of Computer
Organization and Architecture with Digital Hardware Design Early in Undergraduate
Courses, IEEE Transaction on Education Vol 44 no. 2 may 2001, pp109-119
[8] W. Kleinfelde, D. Gray and G. Dudevoir, A hierarchical approach to digital design
using computer-aided design and Hardware description languages. In Proc. 1999
Frontiers Educ. Conf. Nov, 1999. pp 13c6-18~13c6-22
[9] S. Rigo, M. Juliato, G. Arajo and P. Centoducatte, Teaching Computer Architecture
Using an Architecture Description Language. Workshop on Computer Architecture
Education (WCAE), June 2004
ndice
Captulo 1: Introduo ________________________________ 1
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Introduo ........................................................................................1
Componentes de um Computador ....................................................7
A viso do Software.......................................................................10
Concluses .....................................................................................16
Prtica com simuladores ................................................................17
Exerccios.......................................................................................17
Referncias Bibliogrficas Especficas ..........................................18
Captulo 2: Linguagem de Montagem ___________________ 19

2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
Introduo ......................................................................................19
A viso do Software Operandos e Operadores............................21
A viso do Software Operaes lgicas e aritmticas .................22
A viso do Software transferncia de dados................................33
A viso do Software suporte deciso........................................40
A viso do Software suporte procedimentos ............................52
Concluses .....................................................................................59
Prtica com Simuladores................................................................62
Exerccios.......................................................................................64
Captulo 3: Linguagem de Mquina_____________________ 67

3.1
3.2
3.3
3.4
3.5
3.6
3.7
Introduo ......................................................................................67
Uso da linguagem de mquina .......................................................80
A viso do Software ArchC ........................................................82
A viso do Software ELF............................................................86
Concluses .....................................................................................94
Prtica com Simuladores................................................................95
Exerccios.......................................................................................95
ix
Captulo 4: O Processador ____________________________ 97

4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
Introduo ......................................................................................97
Componentes da via de dados ........................................................97
Interligao dos componentes da via de dados.............................101
Unidade de Controle ....................................................................107
Via de dados mono e multi-ciclos ................................................109
Pipeline ........................................................................................111
A viso do Software o pipeline .................................................112
Concluses ...................................................................................115
Prtica com Simuladores..............................................................115
Exerccios.....................................................................................115
Captulo 5: Desempenho do Computador _______________ 117

5.1
5.2
5.3
5.4
5.5
5.6
Introduo ....................................................................................117
Mtricas de desempenho ..............................................................123
A viso do Software benchmarking .........................................125
Concluses ...................................................................................127
Exerccios.....................................................................................127
Captulo 6: Sistema de Memrias______________________ 129

6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
Introduo ....................................................................................129
Memrias Cache ..........................................................................134
Memria principal........................................................................155
Memrias de Massa .....................................................................160
Sistema de memrias e desempenho da mquina.........................168
A viso do Software ....................................................................170
Concluses ...................................................................................173
Exerccios.....................................................................................175
Referncias Bibliogrficas Especficas ........................................177
Captulo 7: Entrada e Sada __________________________ 179

7.1
7.2
7.3
7.4
7.5
7.6
Introduo ....................................................................................179
Mtodos de Controle de E/S ........................................................182
A viso do software Interrupes..............................................186
Concluses ...................................................................................188
Exerccios.....................................................................................191
ndice
xi
Captulo 8: Concluses ______________________________ 193

8.1
8.2
8.3
Introduo ....................................................................................193
Realidades ....................................................................................194
Alm das Realidades ....................................................................197
Apndice A: Caches Revisitadas_______________________ 199

A.1
A.2
Introduo ....................................................................................199
Falha na Escrita............................................................................200
xii
Captulo 1
Introduo
1.1 Introduo
O aluno que chega a cursar a disciplina alvo deste livro, costuma
apresentar um certo grau de conhecimento sobre programao em alto nvel
(C, C++, JAVA e/ou outras), ou est exatamente recebendo estas informaes.
O objetivo deste captulo mostrar o que est por trs deste mundo, o que faz
com que o programa que foi desenvolvido seja executado em um computador,
os papeis do Compilador, do Montador, do Carregador e do Sistema
Operacional, SO.
Inicialmente gostaramos de tratar das mltiplas vises de um
computador, ou seja, como ns enxergamos esta mquina que revolucionou
nossas vidas. Fico me perguntando como podemos apreciar um Da Vinci de
forma to ecltica. Seu mais famoso trabalho, a Mona Lisa, apresenta uma
enorme variedade de interpretaes. De fronte galeria do Louvre que guarda
a obra, muitos curiosos enxergam aquela mulher com um ar enigmtico como
uma obra prima, mas no compreendem a genialidade que existe por trs da
tela. Assimetrias ao fundo, tcnicas de sfumato e a identidade da egria so
apenas vistos por olhos mais curiosos e treinados.
Mas voltemos s nossas mquinas computacionais. Uma criana (e no
somente ela) entende um computador como um grande repositrio de jogos
onde ela pode se divertir. Um usurio compreende um computador como uma
ferramenta que lhe ajuda a digitar textos e encontrar informaes na Internet.
Um analista de sistema v o que outros no enxergam: o computador como o
local onde se materializam seus devaneios (ou dos outros) e de onde ele tira o
seu sustento.
O convite neste livro para irmos alm. Abrirmos a mquina ainda
pouco. Vamos precisar radiograf-la, adentrar suas entranhas e descobrir um
mundo onde tudo minsculo.
1
O que fazer com isto? Por que uma abstrao to detalhada para um
aluno de um curso com nfase em software? Iremos perceber ao longo deste
livro que o usurio de nossos projetos deseja, antes de tudo, um desempenho
razovel da aplicao. Imagine chamar (iniciar) um processador de textos e
esperar meia hora para que ele esteja pronto para uso! Buscar um arquivo e ter
de esperar minutos para que ele esteja disponvel. Isto est fora de nossa
realidade atual.
E o que faz com que nossos softwares sejam eficientes? uma
combinao de tcnicas de software e de hardware. Usar estruturas de dados
adequadas to importante como explorar bem o sistema de memrias. Alm
disto, algumas classes de software exigem um conhecimento profundo da
arquitetura do sistema onde eles sero executados. Trata-se dos softwares
bsicos (System Software). Nesta classe de softwares esto includos
montadores, ligadores, carregadores, compiladores e sistemas operacionais.
Em breve apresentaremos uma viso geral de cada um deles.
Voltando s nossas abstraes, vamos apresentar como hardware e
software podem ser enxergados em camadas. Desta forma definiremos
exatamente o escopo deste livro, sobre que camadas h informaes no texto.
Vamos comear com o Hardware.
A Figura 1.1 mostra as principais camadas de abstrao sobre as quais
um projetista de hardware pode trabalhar. Na camada de DISPOSITIVOS, so
estudados os materiais semi-condutores e suas dopagens com outros
elementos para produzir um transistor, elemento bsico de funcionamento de
um processador. Na camada de CIRCUITO, os transistores so agrupados para
formar um circuito. Na camada de PORTAS, uma operao lgica
materializada em um circuito particular. Na camada de MDULO, diversas
portas so agrupadas para formar um mdulo computacional. Finalmente, na
camada de SISTEMA os mdulos so interligados de tal forma a produzir um
sistema, por exemplo, um processador. Para ajudar no processo de construo
de um sistema eletrnico existem diversas ferramentas para auxlio a projetos,
inclusive ferramentas que permitem a descrio no nvel de sistema e que
geram automaticamente os outros nveis da abstrao. A propsito este
processo de gerar nveis mais baixos de abstrao do sistema chamado de
sntese.
Neste livro abordaremos as camadas de SISTEMA e MDULO, com
eventuais usos de portas lgicas, para construir um processador simples. De
fato, com milhes de transistores presentes em um nico chip, em nossos
tempos, uma tarefa rdua, para no dizer impossvel, projetar um sistema
apenas pensando nos transistores, ou mesmo portas.
Captulo 1: Introduo
Sistema
Mdulo
Porta
Circuito
Dispositivo
G
S
n+
D
n+
Figura 1.1: Abstrao do Projeto de Hardware
Os softwares esto organizados, em relao ao hardware, quanto a sua

proximidade da mquina. Um hardware controlado pelo Sistema
Operacional que presta servios s aplicaes. Quando um programa de
usurio requer alguma informao do hardware, ele a solicita ao Sistema
Operacional e aguarda at que o SO possa traz-la. A Figura 1.2 mostra as
camadas de software que compem um sistema computacional. De fato, esta
organizao em camadas reflete como diversas classes de softwares agem com
relao ao hardware.
Um exemplo real um programa processador de texto. Quando
pressionamos alguma tecla no teclado, estamos de fato usando um mdulo do
hardware que avisa ao sistema operacional que o usurio digitou uma tecla. O
SO, por sua vez, informa ao processador de texto que o usurio digitou um
caractere. O processador de texto recebe este caractere e pede ao SO para
mostr-lo na tela. O SO envia para o monitor (hardware) o cdigo do caractere
a ser mostrado e o monitor o faz. Isto tudo ocorre de forma to rpida que o
usurio tem a sensao de que sua digitao provocou a imediata apario do
caractere na tela.
Um software nada mais que um conjunto de instrues, logicamente
organizado, de tal forma que o hardware possa interpretar e seguir os
comandos. O hardware, por sua vez, uma mquina que faz exatamente o que
est escrito em um software. Acontece que o hardware usa uma forma de
Aplicaes
Sistema
Operacional
Hardware
Figura 1.2: Camadas de Softwares
representao de dados diferente do nosso alfabeto convencional. Um

hardware tem um alfabeto muito simples, com apenas duas letras: 0 e 1.
Assim como podemos escrever qualquer palavra combinando o nosso
alfabeto de 23 ou 26 letras, o hardware tambm pode atribuir significado
combinaes de zeros e uns. Cada letra do alfabeto eletrnico conhecida
como Dgito Binrio, bit. Os bits, em termos de circuitos eltricos, so tenses
diferentes com padres predeterminados. Por exemplo, o bit 0 pode ser
associado a 0 volts enquanto o bit 1 pode ser associado a 5 volts.
Os comandos inteligveis para uma mquina so palavras formadas por
bits. Existem mquinas que aceitam palavras de tamanhos variados, enquanto
outras, mais simples, s admitem um nico tamanho de palavras.
Agora, imaginemos a tarefa simples de criar um conjunto de palavras
binrias de 32bits que formem um programa. Todos os bits tm significados e
devem ser observados. O programa poderia ser algo como:
00100010001100111111111111111111
00100010010101000000000000000100
01110010001100010000000000000010
Captulo 1: Introduo
Do ponto de vista prtico, esta uma programao praticamente

ininteligvel e de difcil manuteno. Ns, como seres humanos, dotados de
inteligncia dita superior, podemos criar smbolos para cada combinao de
bits de tal forma que possamos programar com smbolos. Os smbolos mais
comumente utilizados so chamados mnemnicos. O programa anterior seria
ento interpretado como
addi A, B, -1
addi C, D, 4
mul E, B, B
Ora, nesta forma de escrever, algum significado j fica exposto para um
possvel leitor: as duas primeiras instrues so somas e a terceira instruo
uma multiplicao. Por conveno, addi A, B, -1 significa A = B + (-1).
Por conseguinte, addi C, D, 4 significa C = D + 4. Ora, mesmo neste
princpio de leitura j podermos inferir como construir, de forma simblica o
comando referente a expresso C = A + 8. Tente faz-lo!
O problema que estes comandos, addi e mul, apesar de
significativos para ns, no tm como ser expressos para a mquina seno
usando bits. Assim, faz-se necessrio um processo de converso. A converso
pode ser manual ou utilizando um software capaz de traduzir esta linguagem
mais significativa para ns em uma linguagem que o computador possa
entender. Este software chamado de Montador (Assembler). Deve existir
uma relao biunvoca entre o smbolo e o conjunto de bits correspondente. A
linguagem formada pelo conjunto de mnemnicos de um determinado
computador chamada de assembly ou linguagem de montagem. Uma
palavra interpretvel pelo circuito de um processador chamada de instruo.
Podemos ento dizer que um montador um software capaz de converter
instrues em assembly para instrues de mquina.
Existe ainda mais um nvel comum de abstrao para programao:
linguagens de nvel alto (HLL, High Level programming Languages), ou de
alto nvel. Quando programamos em C ou Java estamos utilizando este outro
nvel de abstrao. Em contrapartida, um programa escrito em assembly dito
de nvel baixo, ou mais comumente, de baixo nvel. Os comandos de uma
linguagem de alto nvel no tm uma relao unvoca com o assembly, ou
seja, os comandos podem ser traduzidos de forma diferente dependendo da
situao. A programao em HLL se abstrai quase que completamente da
plataforma onde ser executado o cdigo de mquina gerado. Para traduzir um
programa escrito em HLL para um assembly especfico usamos um software
chamado Compilador.
A linguagem de alto nvel normalmente independente da mquina

para qual nosso programa ser traduzido. J no o caso do montador. A
Figura 1.3 mostra o caso geral para um trecho de programa em C/Java. Se
usarmos um compilador para MIPS, o assembly gerado ser especfico do
MIPS. O mesmo ocorre para SPARC ou IA32 (Pentium, por exemplo). Da
para baixo, preciso um montador especfico. O cdigo binrio (em bits)
correspondente em cada mquina chamado de cdigo de mquina ou
linguagem de mquina. As tradues apresentadas na figura so fictcias.
for (i=0; i<10; i++){
m=m+j+c;
j=j-i;
}
Compilador
C MIPS
Assembly
MIPS
...
add $17, $18, $19
add $16, $16, $17
sub $20, $20, $21
....
Montador
MIPS
Linguagem
de Mquina
MIPS
...
00000010010100111000100000100000
00000010000100011000000000100000
00000010100101011010000000100010
....
Processador
MIPS R3000
Compilador
C SPARC
Assembly
SPARC
...
add %g4, %g1, %g2
add %g3, %g3, %g4
sub %g5, %g5, %g7
....
Montador
SPARC
Linguagem
de Mquina
SPARC
...
10000100000000010000000000000001
10001000000000001100000000000011
10001110001000010100000000000101
....
Processador
SPARC v8
HLL
Compilador
C IA32
Assembly
IA32
...
add eax, ebx, ecx
sub ax, bx, cx
....
Montador
IA32
Linguagem
de Mquina
IA32
...
10000100000000010000000000000001
10001000000000001100000000000011
....
Processador
Pentium
Figura 1.3: Compilao e Montagem de um cdigo em HLL
Captulo 1: Introduo
1.2 Componentes de um Computador

A abordagem clssica em arquitetura de computadores apresentar a
mquina com cinco componentes bsicos. Isto remonta o modelo de
computao preconizado por Von Neumman e usado at hoje. Neste modelo
h um repositrio para dados e programas que a memria. Uma via de
dados (datapath) por onde os dados da memria so trazidos para o
processador, processados e devolvidos memria. Uma unidade de controle,
que gerencia a via de dados baseada no cdigo (programa) que o usurio
tambm depositou na memria. Finalmente um sistema de entrada e sada
(E/S ou I/O, Input/Output), por onde o computador se comunica com o
mundo externo. Costumamos chamar a unidade de controle junto com a via de
dados de CPU (Central Processing Unit ou UCP, Unidade de Processamento
Central) ou processador. A Figura 1.4 mostra um diagrama dos componentes
bsicos de um computador e suas inter-relaes.
COMPUTADOR
RECEITAS
S
RE E T O
CEI R
TA
S
0
16
32
20
36
24
40
12
28
44
48
64
80
52
68
84
56
72
88
76
92
CONTROLE
S
TE E T O
MPE R
RO
S
VIA DE DADOS
0
1
2
3
4
PROCESSADOR
60
SE
BO T O R
LO
S
ENTRADA
SE
CA TO R
RNE
S
SADA
96
112
128
100
116
132
104
120
136
108
124
140
MEMRIA
Figura 1.4: Componentes de um Computador
A Figura 1.4 apresenta os componentes de um computador, mas possui

tambm algumas figuras bem peculiares. Trata-se de uma analogia para
melhor entender como o computador funciona. Como toda analogia, sempre
h imperfeies, mas o raciocnio desenvolvido a seguir ajuda a limitar e
direcionar nossa imaginao.
O processador uma fbrica de bolos. A memria, um supermercado.
Dentro do processador est o chefe de cozinha. Ele o responsvel pelo bom
funcionamento da cozinha. ele quem d as ordens para mistura dos
ingredientes. A prateleira, dentro de nossa fbrica de bolos, serve para guardar
os ingredientes comprados no supermercado e tambm os bolos que vo
ficando prontos. Esta prateleira, no mundo real, chamada de banco de
registradores. O conjunto de utenslios e forno chamado de Unidade
Lgica e Aritmtica, ULA ou ALU (Arithmetic and Logic Unit).
A memria um grande supermercado. Nele temos muitas prateleiras.
As prateleiras do supermercado so numeradas para que os ingredientes
possam ser facilmente encontrados. Existem setores especficos para cada
ingrediente no supermercado. O chefe de cozinha adquire no supermercado
um livro de receitas e nele esto mostrados os ingredientes e modo de fazer. A
receita anloga ao programa (software). Nela est mostrado o modo de
preparar e os ingredientes. O chefe, ento, instrui seus comandados a
comprarem no supermercado os ingredientes e depois lhes informa como
misturar. Depois de preparado, o bolo vai para a despensa (prateleiras). O
chefe ento manda entregar ao supermercado, onde os bolos sero vendidos.
O supermercado, por sua vez, recebe dos produtores, atravs de uma via
de entrada, os ingredientes para abastecer suas prateleiras. Quando existe uma
compra em atacado, o supermercado manda entregar os ingredientes e
produtos usando uma via de sada. Um exemplo tpico o teclado, que usa a
via de entrada de dados e o monitor, que usa a via de sada de dados. Existem
dois caminhos entre o processador e a memria: uma para cdigos e outro
para dados. Estes caminhos so chamados de barramentos. Assim como as
estradas de entrada e sada, que tambm so barramentos. Em algumas
mquinas existe apenas um barramento para dados e instrues, o que faz com
que os mesmos concorram ao recurso. O barramento de dados bidirecional,
ou seja, tanto traz dados da memria, como os leva de volta. O barramento de
cdigos unidirecional, dado que o supermercado no aceita livros de receitas
usados.
Mais alguns detalhes de nossa analogia: as prateleiras dos
supermercados so do mesmo tamanho das prateleiras da despensa na fbrica
de bolos. Embora seja possvel comprar apenas um ingrediente de uma das
prateleiras do supermercado, comum (veremos porque mais tarde) a
Captulo 1: Introduo
transferncia de uma prateleira inteira da memria para o banco de

registradores. Os registradores so numerados seqencialmente a partir do
zero. Neste livro vamos utilizar uma despensa com 32 prateleiras. As
prateleiras no supermercado tambm so numeradas, comeando do zero, mas,
embora sejam tambm seqenciais, as numeraes salta de quatro em quatro
unidades. Em cada prateleira cabem exatamente quatro ingredientes distintos.
O ingrediente a unidade indivisvel de informao. No nosso caso usamos
um conjunto de 8 bits para o ingrediente. Este conjunto chamado de byte.
Ento, em cada prateleira existem 4 bytes, o que nos faz concluir que cada
prateleira tem capacidade de 32 bits.
Em nosso modelo no admitimos que ingredientes sejam comprados no
supermercado e vo direto para o fogo/forno, nem que bolos vo direto ao
supermercado. Esta uma classe de mquinas chamada Load/Store ou
registrador-registrador. Existem mquinas que flexibilizam esta restrio,
permitindo que ingredientes possam vir direto do supermercado (mquinas
memria-registrador). Existem tambm mquinas onde o bolo fica em um
nico registrador especial chamado Acumulador (mquina baseada em
acumulador). Ainda, existem mquinas onde os ingredientes ficam
acumulados em uma pilha, em vez de um banco de registradores (mquina de
pilha, stack machine). Ns estudaremos neste livro a classe de mquinas
load/store.
Ainda dentro de nossa analogia, podemos derivar um importante
aspecto das organizaes de um computador: o desempenho. Perceba que
muito mais trabalhoso deslocar os ingredientes do supermercado para fbrica e
ento us-los do que guardar em nossa despensa os ingredientes mais
importantes e to logo seja necessrio, imediatamente utiliz-los. Isto tambm
vale, por extrapolao, para quando um produto falta no supermercado. Ai,
preciso esperar ainda mais at que o prximo caminho de entrega saia do
produtor e chegue ao supermercado.
O problema em guardar ingredientes que a nossa despensa tem uma
quantidade de prateleiras limitada, portanto nem todos os ingredientes de um
bolo podem estar ao mesmo tempo na despensa. Alm disto, as receitas que
devem ser preparadas so comandadas pelo usurio, ento no h como saber
quais os ingredientes mais importantes a serem guardados. s vezes, algumas
receitas exigem o preparo em duas fases e precisamos guardar na despensa a
massa para descansar. Isto tudo ocupa lugar na despensa e normalmente
apenas buscamos os ingredientes que sero utilizados mais rapidamente para
no ocuparmos muitas prateleiras. Em nossa fbrica, o chefe de cozinha s
admite a mistura de dois ingredientes por vez, ou seja, nossa ALU opera com
dados em 32 bits sempre.
10
Embora seja ruim em termos de vendas, o supermercado pode, a bem da

velocidade de quem faz as compras, reservar uma regio no seu espao fsico,
onde os ingredientes mais comumente utilizados por seus clientes estejam
disponveis, todos juntos, em prateleiras adjacentes. Isto otimizaria o tempo de
quem precisa comprar uma lista de ingredientes enorme. No mundo real dos
computadores, esta regio do supermercado chamada de memria cache.
Nela, o que importa no a variedade, mas a velocidade, ento tudo
otimizado, por construo, para que as compras saiam mais rpidas.
Em uma receita tpica de nossa fbrica, primeiro esto especificados os
ingredientes e em seguida como mistur-los. um passo-a-passo. Precisa ser
seguido rigorosamente ou a receita no tem o resultado desejado (o bolo no
cresce). O seu anlogo, o programa, normalmente tambm assim: as
variveis so declaradas inicialmente e em seguida vem o cdigo dizendo
como as variveis so processadas. Ento, em um programa existe uma regio
de dados e uma regio de cdigo. Normalmente a regio de cdigo apelidada
text e a regio de dados data.
Uma outra extrapolao do modelo refere-se capacidade de
armazenamento do supermercado. De fato, esta capacidade limitada em
relao aos grandes silos dos produtores. Mas muito mais rpido encontrar
um produto no supermercado da esquina que esperar que o produtor o
transporte at nossa residncia. Esta relao de foras entre velocidade e
capacidade muito comum nos sistemas computacionais. Um silo de um
produtor pode ser comparado ao disco rgido de um computador, o HD (Hard
Disk).
preciso entender que estamos apenas fazendo analogias. Tudo que foi
dito vlido, mas nem tudo que podemos pensar sobre a nossa figura
verdadeiro. Antes de afirmar cabalmente como acontece algo importante ler
o material sobre o assunto, disponvel neste livro e em outros da literatura
especializada.
1.3 A viso do software

Ao longo deste livro uma seo especial sempre se faz presente: a viso
do software. Estamos descrevendo hardware, mas com enfoque em software,
por isto, mesmo que o assunto seja muito voltado ao engenheiro de
computao e afins, sempre devemos apontar como o software, mais
precisamente o programador, enxerga a mquina e/ou quais softwares podem
ser utilizados para extrair o mximo da organizao de um computador.
Captulo 1: Introduo
11
11
Dentro deste esprito, vamos definir o termo Arquitetura de

Computadores, como a viso que um programador de baixo nvel tem sobre a
mquina para qual ele est codificando. Este programador enxerga ento
uma abstrao da mquina chamada Arquitetura do Conjunto de
Instrues, ISA (Instruction Set Architecture). Ela define como possvel
fazer a nossa mquina funcionar.
O Conjunto de Instrues de uma mquina simplesmente o conjunto
de palavras que compem o idioma inteligvel ao processador e outras partes
da organizao do computador. Algumas destas instrues podem afetar a
bom funcionamento da mquina, o que, no passado, levou at perdas de
partes do hardware. Para evitar tal situao, algumas das instrues foram
selecionadas, na maioria das arquiteturas, para compor um conjunto de
instrues privilegiadas. Este conjunto rigorosamente controlado pelo
Sistema Operacional, ou seja, um software que deseja fazer uso de tais
instrues precisa de permisso especial. Quem constri um Sistema
Operacional precisa, por sua vez, prover os servios necessrios proteo
da mquina e dos processos que nela so executados. Um software que roda
sobre o sistema operacional dito software do usurio.
Vamos de forma introdutria mostrar as atribuies bsicas do
Sistema Operacional. Depois seguiremos com a apresentao de outros
softwares bsicos.
O Sistema Operacional o software bsico de maior importncia

dentro do sistema computacional. Ele controla as funes bsicas do
computador, incluindo o gerenciamento de memria e o I/O. O Sistema
Operacional um software baseado em eventos, isto , ele realiza tarefas em
respostas comandos, chamadas de programas de usurios, de dispositivos
de Entrada e Sada etc.
Os sistemas operacionais modernos tm aparncia parecida, mas suas
funcionalidades podem diferir muito. Uma possvel abordagem a
minimalista, onde apenas as funcionalidades mais bsicas esto presentes no
SO. Outra abordagem a completa, onde toda e qualquer funcionalidade
deve estar presente. Alguns tm uma interface com usurio bastante
amigvel, mas falham em desempenho ou confiabilidade. Outros so bastante
confiveis, mas no tm uma boa interface. Em suma, nenhum sistema
operacional completo e melhor que os outros em todos os aspectos.
A viso do software
1.3.1 O Sistema Operacional
A viso do software
12
Uma das principais caractersticas dos sistemas operacionais sua

capacidade de gerenciar a execuo de diversos softwares do usurio ao
mesmo tempo.
Dois componentes so importantes no projeto de um SO: o kernel e os
programas de sistema. O kernel o corao do SO. Ele responsvel pelo
escalonamento de tarefas, sincronizao, proteo/segurana, gerenciamento
de memria e interrupes. O kernel tem controle total da mquina, conhece
seus registradores, temporizadores, palavras de status etc. Muitos so
adeptos do microkernel, ou seja, de um kernel com mnimas funcionalidades.
Isto transforma boa parte da funcionalidade do SO como um todo em
programas de sistema o que permite, praticamente, reiniciar as
funcionalidades da mquina sem precisar deslig-la. A alternativa ao
microkernel o SO monoltico, onde todas as funcionalidades necessrias ao
funcionamento da mquina esto em um nico e grande processo.
parte desta discusso, talvez o mais interessante mecanismo do
sistema operacional seja a iluso de ptica que ele nos envolve ao usarmos
mltiplas tarefas ao mesmo tempo. Em um sistema com uma nica tarefa, a
ocupao do processador pode chegar a ser mesmo muito pequena, pois a
maior parte do tempo ele est esperando um dado ou algo parecido. Quando
executamos mais de uma tarefa, o tempo do processador dividido (de forma
muito sensata, com tcnicas especializadas) para os dois processos. Como a
velocidade de execuo de cada trecho da tarefa muito alta, ns temos a
sensao de estarmos utilizando os dois processos ao mesmo tempo. Isto leva
a necessidade de sincronizao e controle de recursos. A sensao para um
processo, entretanto, que ele dispe da mquina inteira apenas para si.
Quando iniciamos um computador (ligamos o boto ON/OFF) o
processador inicializado e depois comea a executar o kernel do SO. A,
este toma conta do restante do processo de inicializao. Normalmente ele
culmina com a apresentao da Interface grfica para o usurio. Da o
usurio vai iniciar seus prprios programas, o que significa na prtica,
solicitar ao Sistema Operacional, espao para executar aquela tarefa. Vamos
ver adiante, que um programador segue um caminho alternativo: ele precisa,
depois de confeccionar seu programa, usar um compilador e um montador
para gerar um cdigo executvel.
1.3.2 Outros Softwares Bsicos

J mostramos a idia geral que est por trs do compilador. Ele tem a
tarefa de transformar um cdigo em HLL para um cdigo assembly.
Normalmente uma linha de cdigo em linguagem de alto nvel se traduz por
uma seqncia de linhas de cdigo em assembly, assim programar em alto

nvel aumenta a produtividade.
No passado, muitos compiladores e sistemas operacionais eram
construdos em assembly. Hoje, a presena de compiladores otimizantes nos
permite criar outros compiladores e sistemas operacionais a partir de HLLs.
Certamente que os pontos crticos destes softwares bsicos so investigados
com mais ateno, em assembly, para diminuir qualquer imperfeio
(normalmente no na funcionalidade, mas no desempenho) no cdigo gerado.
O montador tambm um software bsico que ns j citamos. Ele
basicamente tem a misso de gerar um cdigo binrio que ser carregado na
memria do computador para ser executado. O montador, ou melhor, o
projetista do montador, precisa conhecer profundamente a mquina em que o
software gerado vai ser executado.
O montador tambm gera um tabela de smbolos, que representam
endereos do programa. Ns estudaremos mais adiante as instrues de
salto, o que nos far entender de onde vm estes smbolos.
medida que os programas foram se tornando muito grandes, uma
modularizao passou a ser importante. Isto significa que podemos construir
mdulos separados de um programa, compil-los independentemente e em
seguida lig-los para gerar um cdigo executvel. A modularizao nos
permite criar um conjunto de funes muito usadas e deix-las compiladas
em uma biblioteca. Quando um software do usurio precisa de uma funo
ele simplesmente liga ao seu cdigo a biblioteca. Um software bsico
chamado de ligador (linker) o responsvel por esta tarefa.
Finalmente o cdigo executvel gerado. A partir da preciso um
carregador para pr este cdigo na memria e assim ele ser executado. O
carregador um outro software bsico, mas ele normalmente um mdulo
especfico do SO. Gostaramos de destacar aqui, mesmo que seja em forma
de repetio, que um programa para ser executado ele precisa estar na
memria. Este um conceito muito antigo, chamado conceito de programa
armazenado (stored program concept). Veja que em nossa figura da
analogia dos componentes do computador, as receitas utilizadas pelo chefe
de cozinha vm dos livros que esto no supermercado, na seo de receitas.
Sem estes livros ele no capaz de misturar os ingredientes para surtir o
efeito almejado.
A Figura 1.5 mostra a inter-relao entre compilador, montador,
ligador e cerregador.
13
13
A viso do software
Captulo 1: Introduo
14
for (i=0; i<10; i++){

m=m+j+c;
j=j-i;
}
Processador
MIPS R3000
HLL
Memria
Compilador
C MIPS
Assembly
MIPS
...
add $17, $18, $19
add $16, $16, $17
sub $20, $20, $21
....
Montador
MIPS
...
00000010010100111000100000100000
00000010000100011000000000100000
00000010100101011010000000100010
....
A viso do software
Linguagem
de Mquina
MIPS
Carregador
(SO)
Cdigo
Executvel
Ligador
MIPS
...
00000010010100111000100000100000
00000010000100011000000000100000
00000010100101011010000000100010
....
...
00000010010100111000100000100000
00000010000100011000000000100000
00000010100101011010000000100010
....
biblioteca
Figura 1.5: Esquema do Compilador/Montador/Ligador/Carregador
Na ligao apresentada anteriormente, chamada esttica, todo o

cdigo da biblioteca anexado ao programa do usurio, mesmo que ele v
utilizar apenas algumas funes. Isto faz com que o programa final fique
muito grande. Existe uma outra espcie de ligao muito freqentemente
utilizada: a ligao dinmica. As bibliotecas de ligao dinmica, DLLs
(Dynamic Linked Library) so mdulos que so invocados pelo programa
do usurio durante sua execuo. Isto faz com que o carregador no precise
alocar todo o cdigo na memria. As DLLs podem ento ser carregadas
apenas no momento de seu uso. Outra coisa interessante relativa s DLLs
que um software no precisa ser re-ligado sempre que uma nova DLL (que
corrige um defeito, ou que melhora o desempenho) disponibilizada. O nus
15
15
Captulo 1: Introduo
natural com as DLLs que o tempo de ligao transferido para dentro do

tempo de execuo do processo.
1.3.3 A Mquina Virtual Java

A mquina Virtual Java um software do usurio capaz de interpretar
bytecodes Java. O termo interpretar um pouco diferente de executar. A
execuo de um cdigo s feita pela mquina real. Os cdigos
interpretveis so cdigos binrios de uma mquina que no existe,
idealizada em software e que so inteligveis para um software simulador de
uma arquitetura. A Figura 1.6 mostra como so realizadas a compilao e
execuo de um cdigo em Java. O compilador Java transforma o programa
em bytecodes e gera uma arquivo .class. Os arquivos .class podem ser
executados em qualquer plataforma (combinao de Processador e SO),
desde que haja uma Mquina Virtual Java, JVM (Java Virtual Machine)
instalada. As bibliotecas Java, tambm em bytecodes, podem ser carregadas
diretamente pela JVM sob demanda.
Bibliotecas
Java
Programa
em Java
Compilador
Java
ByteCodes
Java
(.class)
Mquina
Virtual
Java
O sucesso de uma mquina virtual s pode ser alcanado se existirem

implementaes para muitas plataformas, o que torna a portabilidade do
cdigo muito atrativo. Existe, porm, uma limitao importante: por melhor
que seja a mquina virtual, a velocidade de interpretao 10 vezes mais
lenta que uma execuo com cdigo nativo. Isto levou ao desenvolvimento de
um mdulo do interpretador com capacidade de converter bytecodes em
linguagem de mquina. So os compiladores just-in-time, JIT (Just-In-Time
compilers). Toda vez que o interpretador reconhece um trecho de cdigo que
freqentemente utilizado ele usa o JIT para convert-lo em cdigo nativo e
da prxima vez que for chamado o trecho, ao invs de ser interpretado, ele
executado. A Figura 1.7 mostra a integrao do JIT com os demais
A viso do software
Figura 1.6: Compilao de um cdigo em Java
16
componentes do processo de criao e execuo de um software em Java. O

interpretador invoca o JIT que converte mtodos em cdigos executveis.
Quando forem invocados na prxima vez, estes mtodos podem ser
executados diretamente na arquitetura onde est rodando a JVM.
Bibliotecas
Java
Programa
em Java
Compilador
Java
ByteCodes
Java
(.class)
Mquina
Virtual
Java
JIT
Mtodos
Java
Executveis
Figura 1.7: Mquina Virtual Java com JIT
1.4 Concluses
Vimos que um computador uma mquina complexa, mas totalmente
controlvel e determinstica1. Os componentes bsicos de um computador so:
memria, controle, via de dados, entrada e sada. Todos os programas em alto
nvel construdos pelo usurio precisam passar por um processo de converso
para a linguagem da mquina correspondente. Os compiladores, montadores e
ligadores, usados em conjunto geram um cdigo que capaz de ser executado
na mquina. Um sistema operacional um software que blinda o hardware de
tal forma a prover controle sobre os processos que so executados. Nele existe
um mdulo carregador que encarregado de transferir os programas para a
memria, a partir de onde eles podem ser executados. O escopo deste captulo
apresenta o nvel de abstrao que vamos utilizar, ou seja, um nvel de
1
O processo de construo dos chips por vezes nos levam a algumas imperfeies na implementao de um
processador o que permite um certo grau de incerteza na execuo dos cdigos, mas isto minimizado pelo
processo de qualidade e de testes por onde passam os processadores fabricados.
Captulo 1: Introduo
Arquitetura de Computadores, que envolve o conhecimento mnimo de

organizao da mquina para dela podermos extrair o mximo de desempenho
possvel.
Este trabalho est organizado da seguinte forma: o Captulo 2 introduz o
conjunto de instrues do MIPS, uma arquitetura simples e de fcil
inteligibilidade, contudo de alto desempenho. O Captulo 3 descreve como a
linguagem assembly do MIPS traduzida para cdigo de mquina e viceversa. O Captulo 4 apresenta o hardware capaz de executar nossos programas.
Algumas abordagens de como melhorar o desempenho de uma mquina so
traadas. O Captulo 5, a extenso natural do 4. Nele os aspectos de
desempenho so catalogados e a importncia dos testes realada. O Captulo
6 traz toda a teoria sobre o sistema de memria usado convencionalmente nos
processadores atuais. O Captulo 7 mostra como os diversos componentes de
um computador so interligados. Por fim, as concluses so apresentadas no
Captulo 8, bem como o caminho que est por vir, o que esperar dos
computadores nas prximas dcadas.
Dois grandes captulos formam a base da leitura: o Captulo 2 e o
Captulo 6. Todos os captulos tm um conjunto de exerccios de fixao
incluindo temas de pesquisa na web que complementam a leitura do texto.
1.5 Prtica com Simuladores

Existem inmeros simuladores disponveis para uso conjunto com os
textos deste livro. Vamos utilizar basicamente o SPIM e o dinero, ferramentas
amplamente divulgadas na comunidade acadmica, mas tambm utilizaremos
nossos prprios simuladores, que tentam serem ainda mais didticos e esto
disponveis para modificao de forma simples. O site do livro traz todos os
links para os simuladores utilizados.
1.6 Exerccios
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
Pesquise na web e produza um resumo sobre Firmware.

Pesquise na web e produza um resumo sobre Plug and Play.
Pesquise na web e produza um resumo sobre boot process.
Pesquise na web e produza um resumo sobre BIOS.
Pesquise na web e produza um resumo sobre perifricos.
Pesquise na web e produza um resumo sobre cross compilers.
Pesquise na web e produza um resumo sobre pseudo-instrues.
Pesquise na web e produza um resumo sobre a histria dos
processadores.
17
18
1.9
1.10
1.11
1.12
1.13
Pesquise na web e produza um resumo sobre Mquina Virtuais.

Pesquise na web e produza um resumo sobre manufatura de chips.
Pesquise na web e produza um resumo sobre RISC.
Pesquise na web e produza um resumo sobre CISC.
Crie uma figura como a 1.1 onde sero mostrados os nveis de
abstrao dos programas: HLL, Linguagem de Montagem e
Linguagem de mquina.
1.14 Crie uma figura como a 1.2 onde sero mostradas as camadas de
software que contemplem os arquivos.class, a JVM, o SO e a mquina.
1.7 Referncias Bibliogrficas Especficas

Este livro tem como referncias bsicas textos consagrados da
Organizao e Arquitetura de Computadores, porm o material foi
cuidadosamente trabalhado para ser apresentado ao leitor com um enfoque
bastante realista em termos de software. Uma pitada da experincia deste autor
tambm expressa e bibliografias particulares so apresentadas ao final de
cada captulo.
[1] Jean-Loup Baer, Computer Systems Architecture, 1980
[2] Gerrit Blaauw & Frederick Brooks, Computer Architecture: concepts and
evolution, 1997
[3] David Paterson & John Henessy, Computer Organization and Design,
3ed., 2004
[4] Tanenbaum, Structured Computer Organization, 4 ed., 1998
[5] Willian Stalling, Arquitetura e Organizao de Computadores, 5ed. 1997
[6] Linda Null & Julia Lobur, The essentials of computer organization and
architecture. 2003
[7] Mostafa Abd-El-Barr, Hesham El-Rewini, Fundamentals of computer
organization and architecture, 2005
Captulo 2
Linguagem de
Montagem
2.1 Introduo
J vimos os fundamentos da programao de computadores, sob o ponto
de vista da inteligibilidade dos comandos. Sabemos tambm que a
programao em baixo nvel, principalmente em linguagem de mquina,
difcil e de compreenso rdua para ns seres humanos, embora seja
inteligvel para a mquina.
Neste captulo vamos conhecer os comandos de linguagem de
montagem que nos permitem escrever programas para serem executados no
MIPS. Nossa abordagem busca aprender os principais comandos divididos por
categorias funcionais: aritmtica; transferncia de dados; suporte tomada de
deciso; e a procedimentos.
Vamos iniciar pensando um pouco em forma de analogia: aprender um
idioma, de uma mquina ou no, requer conhecer sua palavras. Um dicionrio
um guia importante para quem est aprendendo as primeiras palavras. Assim
como um idioma, uma linguagem de montagem tambm sofre constantes
transformaes, normalmente levando a um novo produto no mercado. Um
exemplo no muito distante foi a introduo do conjunto MMX nas mquinas
Pentium.
A expressividade de um idioma medida pelo nmero de verbetes
conhecidos da lngua. No se pode afirmar aqui que um indivduo falante do
portugus, com um vocabulrio de 15.000 palavras, seja algum que no tenha
muitas habilidades de comunicao. De fato um adulto usa entre 13.000 e
14.000 palavras no cotidiano e um dicionrio pequeno contem 150.000
verbetes. Para termos uma idia, o vocabulrio possvel de um computador,
que usa palavras de tamanho fixo de 32 bits, de apenas 4.294.967.296
palavras. Nada mal, no mesmo? Entretanto, no caso da mquina, existe uma
necessidade de tornar esta expressividade uma realidade, ou seja, preciso
19
20
fazer com que um hardware possa executar estas instrues e que exista um
compilador/montador eficiente para gerar o cdigo de mquina
correspondente. Sob este prisma, a realidade bem diferente. Vamos aprender
ao longo deste texto que a simplicidade favorece o desempenho, ento o
conjunto de instrues que utilizaremos de cerca de uma centena de palavras
com suas flexes.
Esta mxima da arquitetura de computadores foi levantada em tempos
remotos, mas ainda hoje uma realidade. Ns poderamos utilizar qualquer
conjunto de instrues para nosso texto, entretanto, escolhemos o do MIPS
por sua simplicidade. Talvez o conjunto de instrues mais convencional e
mais estudado seja o da famlia 80x86, mas para um curso introdutrio, o do
MIPS nos permite adentrar em detalhes da organizao que seriam intratveis
com uma arquitetura da complexidade de um Pentium.
Quando a organizao de um computador est em fase de projeto, o
formato do conjunto de instrues deve ser determinado o quanto antes. Esta
uma deciso duradoura, visto que uma nova arquitetura, mesmo que melhor
que sua antecessora, implica em perda dos softwares que foram projetados
anteriormente. Esta compatibilidade de software talvez uma das grandes
limitaes para o surgimento de novas arquiteturas. Imagine que a Intel
descontinuasse completamente o suporte aos softwares atuais, em nome de
uma arquitetura que permitisse um ganho de desempenho de 30%. Ora,
nenhum grande usurio estaria interessado em perder todo o seu investimento
em software para ganhar um pouco de desempenho na mquina. Esta
compatibilidade de software to forte, que hoje o Pentium IV enxergado
como uma mquina escalar (no mximo uma instruo executada por vez)
pelo software, mas no fundo ela traduz os comandos para um outro patamar,
onde mais de uma instruo possa ser executada por vez (mquina superescalar).
A eficincia de um conjunto de instrues pode ser medida de diversas
formas: o tamanho que o programa vai ocupar; a complexidade da
decodificao pela mquina; o tamanho das instrues; e o nmero de
instrues. O MIPS utiliza um conjunto cujas instrues so de tamanho fixo,
de 32 bits. Isto bom para decodificao, mas um programa ocupa muito
espao na memria. A propsito, a organizao da memria afeta diretamente
o formato das instrues. Vamos trabalhar com uma memria que utiliza
palavras de 32 bits, mas enderevel a bytes, o que significa que cada byte tem
uma posio (endereo) particular. Isto implica que palavras adjacentes
diferem de 4 unidades de endereo na memria.
Captulo 2: Linguagem de Montagem
21
Nas sees seguintes iremos tratar de um tpico eminentemente

relacionado viso do software. Por isto o restante deste captulo est
destacado.
O nome computador nos leva a pensar de imediato em uma mquina

que computa, ou seja, calcula. Certamente uma forte nfase em clculos
desejada em um computador, o que implica que ele precisa saber realizar
operaes aritmticas. Ora, uma operao aritmtica composta de
operadores e operandos. Os operadores bsicos so: soma, subtrao,
multiplicao e diviso. Ns utilizamos parcelas em pares para guardar os
operandos. As parcelas recebem nomes em particular, por exemplo, numa
subtrao existe o minuendo, o subtraendo e o resto (ou diferena), que o
resultado da operao. Na soma, as parcelas so denominadas parcelas.
Enfim, mesmo quando estamos realizando uma soma com trs parcelas, ns
fazemos as contas primitivas com dois algarismos, invariavelmente. Esta
abordagem seguida pela mquina em seus comandos aritmticos.
Genericamente falando, uma instruo composta de um operador e
zero ou mais operandos, sendo mais comum quantidades menores ou iguais a
trs. No MIPS este valor mximo dois, ou seja, no mximo cada operao
pode utilizar dois operandos por vez.
Uma outra caracterstica importante o local de armazenamento dos
operandos. Em nossa analogia, assinalada na Figura 1.4, os operandos
(ingredientes) esto sempre guardados na despensa (banco de registradores).
Eles, ento, so misturados dois a dois para produzir o resultado de uma
receita. No MIPS, os operandos de uma instruo so sempre guardados no
banco de registradores e os resultados das operaes (quando existem),
tambm so endereados aos registradores. Todavia, existe uma classe de
instrues que porta um dos operandos dentro da sua prpria codificao
binria. So os chamados operandos imediatos. Esta uma exceo regra
geral, mas muito comumente utilizada. Ento, um dos operandos pode vir de
um registrador ou da prpria instruo. Veja que isto no altera o nmero de
operandos, mas apenas de onde eles vm. Apenas um operando pode estar
contido na codificao de uma instruo. Voltando a nossa analogia, o
exemplo seria: quando o chefe de cozinha deseja comprar uma nova receita
ele vai ao supermercado e a traz para a fbrica. Ele aproveitaria esta ida ao
supermercado para trazer tambm algum ingrediente junto com ele.
Os operandos podem ser de tipos e tamanhos diferentes, por exemplo:
bytes, palavras, meias palavras (halfword), caracteres, nmeros sinalizados,
A viso do software
2.2 A viso do software Operandos e Operadores
22
nmeros no sinalizados, endereos etc. No MIPS, a ALU s realiza

operaes com operandos de 32 bits, entretanto os operandos,
principalmente imediatos, tm tamanhos diferentes, o que faz com que seja
necessrio um ajuste para 32 bits antes dos mesmos serem enviados para a
ALU.
Um dado em binrio no carrega consigo qualquer informao
semntica, ou seja, uma seqncia de zeros e uns no indica se tratar de um
nmero sinalizado, um nmero no sinalizado, uma cadeia de caracteres ou
um endereo. Quem d significado ao operando a operao. Uma operao
que usa operandos sinalizados vai interpretar seus operandos como sendo
nmeros sinalizados. Uma outra operao, que usa operandos no
sinalizados vai interpretar os mesmos, como nmeros no sinalizados. Por
exemplo, o nmero binrio 111111111111111111111111111111102
pode ser interpretado como -2 ou 4.294.967.294. Isto s depende de qual
operao o utiliza.
Finalmente, existem classes de operaes: lgica e aritmtica;
transferncia de dados; suporte tomada de deciso; e suporte a
procedimentos. Estas classes tm um certo impacto em como cada instruo
ser executada pelo processador.
A viso do software
2.3 A viso do software Operaes lgicas e aritmticas

Estudaremos nesta seo as instrues lgicas e aritmticas. Soma,
subtrao, multiplicao, diviso, e (and), ou (or), ou exclusivo (xor), nou
(nor), shift left e shift right. No trataremos o suporte a operandos em pontoflutuante (uma representao de mquina para nmeros reais).
A mais intuitiva operao aritmtica a soma. No MIPS uma soma
poderia ser escrita da seguinte forma:
add a, b, c
isto significa a = b + c. Os operandos possuem ordem predeterminada

em uma operao: a primeira varivel a aparecer numa soma , de fato,
associada ao resultado da operao, a segunda e terceira variveis so as
parcelas. Variveis pode ser intuitivo para um programador em alto nvel,
mas quem trabalha com linguagem de montagem sabe que elas esto
associadas a registradores. J mencionamos que as operaes do MIPS so
realizadas sobre operados e que os mesmos esto, via de regra, em
registradores. Ento, quem faz esta associao: registrador - varivel? Esta
uma das tarefas do compilador, chamada alocao de registradores. Por
23
23
enquanto vamos deixar esta discusso fora do nosso caminho e vamos

assumir que algum (ou algo) fez esta associao. J vimos que os
registradores so numerados de 0 a 31, ento, vamos utilizar alguns deles
para associar nossas variveis. Por conveno utilizamos os registradores
numerados entre 8 e 25. Veremos mais tarde o arrazoado que existe por trs
desta conveno. Bem, ento vamos reescrever o cdigo acima (de apenas
uma instruo) com as seguintes associaes: registrador 8 = varivel a;
registrador 9 = varivel b; e registrador 10 = varivel c. O cdigo seria
ento:
add $8, $9, $10
Veja que os nmeros dos registrados so precedidos de um caractere $ para

no restar dvidas que se trata de um operando que est no banco de
registradores e no de um operando imediato.
Um dos problemas encontrados com esta forma de codificar sua
rigidez. Aqui no h espaos para interpretaes dbias. Devemos escrever
exatamente de forma inteligvel para o montador sob pena de nosso cdigo
de mquina gerado no realizar a tarefa desejada. Agora vamos analisar
uma expresso aritmtica, comum em HLLs, para sabermos como ela pode
ser escrita em linguagem de montagem. A expresso seria:
a = b + c + d + e
add $8, $9, $10

add $8, $8, $11
add $8, $8, $12
# a = b + c
# a = a + d => a = (b+c) + d
# a = a + e => a = (b+c+d) + e
Veja que foi necessrio fracionar a soma em diversas fases, tomando

proveito da propriedade da associatividade da soma. Surgiu tambm na
codificao uma espcie de ajuda aps a instruo. O smbolo # indica para
um montador que o restante da linha deve ser menosprezado. Isto permite ao
programador explicitar sua idia para um colega de trabalho e/ou para ele
mesmo, quando precisa lembrar exatamente como um problema foi resolvido.
Usamos estes campos de comentrios para explicitar as variveis, j que as
variveis foram associadas a registradores anteriormente a confeco do
cdigo.
A viso do software
Considerando as variveis a a e associadas aos registradores 8 a 12

respectivamente, podemos escrever:
24
Um outro detalhe: no possvel escrever duas instrues em uma

nica linha de comando. Cada linha de cdigo precisa conter no mximo
uma instruo.
Vamos agora aprender a segunda instruo aritmtica: a subtrao.
Por analogia a subtrao tem como operador a palavra sub e os operandos
so dispostos exatamente como na soma. Ento,
sub $8, $9, $10
# $8 = $9 - $10 ou a = b - c
significa que a varivel associada a $8, por exemplo a, recebe o valor da

subtrao do minuendo $9, associado a b, pelo subtraendo $10, associado a
varivel c. Assim realizamos a seguinte operao aritmtica: a = b c.
Vamos a um exemplo mais elaborado:
a = b + c (d e)
Esta expresso pode ser quebrada em b + c e d e e depois os

resultados intermedirios subtrados para encontramos o resultado final. A
codificao (com as variveis a a e associadas a $8 a $12 respectivamente)
seria:
A viso do software
add $8, $9, $10

# a = b + c
sub $13, $11, $12 # temp = d - e
sub $8, $8, $13
# a = a - temp => a = (b+c) (de)
Veja nesta soluo que precisamos usar um registrador a mais ($13)

para guardar um valor intermedirio de nossa expresso. Naturalmente, com
o nosso conhecimento aritmtico poderamos evitar o uso deste registrador
extra.
Mas o que mais importante neste instante percebermos que muitas
vezes precisamos armazenar valores temporrios em registradores. Isto
restringe ainda mais o uso de registradores para armazenar as variveis de
um programa. Se um determinado programa tem mais de 32 variveis (ou,
por conveno, mais de 18 variveis, que a poro dos registradores
disponveis para uso das variveis) ento alguns valores de variveis
precisam ser guardados na memria. Quando eles so necessrios para
realizao de uma expresso eles so buscados para dentro do banco de
registradores e operados normalmente. Vamos ver mais frente como
podemos trocar dados entre a memria e o banco de registradores.
Continuando com nossas expresses aritmticas, vamos introduzir
agora mais uma possibilidade de soma. comum em HLLs encontramos
25
25
expresses que somam uma constante a uma expresso, por exemplo:

a = a + 1 (que igual a a++). Podemos ento escrever em uma nica
instruo de soma tal expresso (considerando a varivel a associada ao
registrador $8):
addi $8, $8, 1
# a = a + 1
Nesta instruo, somamos o valor do registrador a um nmero chamado

imediato. Ele no est armazenado no banco de registradores, mas sim na
codificao binria da prpria instruo.
Neste ponto precisamos definir os valores mximos de cada operando.
Considerando que a nossa ALU s opera nmeros de 32 bits, podemos usar
nmeros naturais (no sinalizados) no espao entre 0 e 4.294.967.295 ou
nmeros inteiros (sinalizados) entre 2.147.483.648 e +2.147.483.647.
Naturalmente quando operamos com nmeros imediatos, este limite cai para
algum valor menor, dado que os 32 bits disponveis para codificar a
instruo so usados no somente para a especificao da operao, mas
tambm so reservados alguns bits para o prprio valor imediato. No caso do
MIPS este valor vai de 0 a 65.535 para nmeros naturais e de 32.768 a
+32.767 para nmeros inteiros. Para valores de constantes maiores que os
limites especificados preciso armazenar um dado na memria ou construlo em parcelas. Veremos como mais tarde.
Bem, agora j conhecemos os limites que podemos trabalhar. Uma
informao ainda ficou de fora: como saber se estamos operando nmeros
naturais ou inteiros. Existem instrues especiais para operar com nmeros
naturais. Uma soma de nmeros naturais seria especificada assim:
# a = b + c
Isto significa que os valores contidos nos registradores $9 e $10 sero

tratados como nmeros naturais pela instruo. preciso um cuidado
redobrado ao utilizarmos valores prximos aos limites de armazenamento de
dados, isto porque de responsabilidade do programador cuidar para que o
resultado caiba no registrador de destino especificado. Sabemos que
freqentemente uma adio envolvendo dois nmeros naturais de 4
algarismos nos leva a um resultado com cinco algarismos. Ora, sabendo que
cada registrador tem apenas 32 bits, o resultado de nossas operaes precisa
caber nestes 32 bits.
Uma conta que tem como resultado um nmero maior que 32 bits ir
gerar um erro chamado de overflow. Erros de overflow podem ser ignorados
pela mquina e ai o resultado vai ser mesmo errado. Toda a confiabilidade
A viso do software
addu $8, $9, $10
26
do cdigo depende do programador. Quando um erro de overflow no

ignorado pela mquina, ela gera o chamado a uma exceo. Trataremos
deste assunto mais tarde, mas ao menos, saberemos que a nossa conta gerou
um erro.
Instrues que operam com nmeros naturais no geram excees e
instrues que operam com nmeros inteiros sempre geram excees.
Portanto, addu no gera exceo e add gera.
Por extenso temos ainda a instruo subu. Por exemplo:
subu $8, $9, $10
# a = b - c
que realiza uma subtrao com nmeros naturais. Mais uma vez lembramos
que subu no gera exceo e o programador precisa se precaver para evitar
erros em seus programas.
Finalmente nos deparamos com a instruo addiu. Esta instruo
opera com nmeros naturais inclusive sendo um dos operando um valor
imediato. Por exemplo, uma constante 4 poderia ser adicionada a um
registrador $8 associado a uma varivel a da seguinte forma:
addiu $8, $8, 4
# a = a + 4
A instruo addiu no gera exceo quando ocorre overflow.

Vamos sumarizar na Tabela 2.1 as instrues que conhecemos at o
presente momento.
A viso do software
Categoria
Aritmtica
Nome
Exemplo
Operao
Comentrios
add
sub
add $8, $9, $10

sub $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addi
addi $8, $9, 40
$8 = $9 + 40
addu
subu
addu $8, $9, $10

subu $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addiu
addiu $8, $9, 40
$8 = $9 + 40
Overflow gera exceo

Overflow gera exceo
Overflow gera exceo
Valor do imediato na faixa
entre 32.768 e +32.767
Overflow no gera exceo
entre 0 e 65.535
Tabela 2.1: Operaes Aritmticas do MIPS
Nosso prximo passo conhecer as instrues de multiplicao e

diviso. A implementao de uma multiplicao em hardware no to
simples como um somador/subtrator. A multiplicao costuma ser muito
demorada para ser executada e devemos tentar evit-la ao mximo. A diviso
ainda mais lenta e complexa. Entretanto, no vamos simplesmente abdicar
27
27
delas, mas us-las com restries, onde elas no podem ser substitudas por
expresses mais simples.
Vamos comear pensando em uma multiplicao de dois nmeros de 4
algarismos cada. O resultado desta multiplicao ficar, provavelmente, com
8 algarismos. Isto significa que ao multiplicarmos um nmero com n
algarismos por outro com m algarismos, o resultado ser um nmero com
n+m algarismos. No caso do MIPS, a operao de multiplicao ser
realizada sobre dois nmeros de 32 bits. Isto implicar em um resultado de
64 bits. Ora, nenhum registrador tem 64 bits, ento para tornar esta
operao exeqvel, dois registradores extras foram criados: HI e LO, ambos
de 32 bits. HI e LO, usados em conjunto, propiciam que resultados de 64 bits
sejam armazenados nele. Assim, a multiplicao tem um destino fixo e
obrigatrio: o par HI, LO. Por isto ao multiplicarmos dois nmeros
precisamos apenas especificar quais os registradores que os guardam. A
operao mult. Exemplo:
mult $8, $9
# HI, LO = $8 x $9
O registrador HI guarda os 32 bits mais significativos (mais esquerda) do

resultado, enquanto o registrador LO guarda os 32 bits menos significativos
(mais direita). Em nenhuma ocasio tratado overflow. O desenvolvedor
do software deve prover mecanismos suficientes para evit-lo. mult
considera os dois operandos como sendo nmeros sinalizados. Vamos supor
o exemplo acima, onde $8 contem o valor 16 e $9 contem 2.147.483.647. O
resultado da multiplicao, em binrio, com 64 bits, seria:
O registrador HI receberia ento:

0000 0000 0000 0000 0000 0000 0000 01112
e o registrador LO receberia:
1111 1111 1111 1111 1111 1111 1111 00002.
Se o valor de $8 fosse 16, o resultado final seria:
1111 1111 1111 1111 1111 1111 1111 1000 0000 0000 0000 0000 0000 0000 0001 00002
A viso do software
0000 0000 0000 0000 0000 0000 0000 0111 1111 1111 1111 1111 1111 1111 1111 00002
28
ou seja, HI receberia 1111 1111 1111 1111 1111 1111 1111 10002 e
LO receberia 0000 0000 0000 0000 0000 0000 0001 00002.
O hardware multiplicador realiza uma tarefa muito parecida com a
qual fazemos na escola fundamental. Para operar com nmeros sinalizados,
ele simplesmente encontra os valores absolutos e faz a multiplicao. Depois
ele analisa os sinais. Se eles divergirem significa que o resultado negativo,
caso contrrio o resultado positivo.
H ainda uma outra operao de multiplicao que interpreta seus
operandos como nmeros no sinalizados. Trata-se da instruo multu.
multu opera exatamente da mesma forma que mult, a menos do tratamento
dos sinais. Exemplo:
A viso do software
multu $8, $9
# HI, LO = $8 x $9
As operaes de multiplicao, mult e multu no fazem qualquer

tratamento de overflow. Mais uma vez repetimos: cabe ao programador
determinar se existe risco na realizao das multiplicaes.
Finalmente, existe uma instruo, mul, que opera uma multiplicao
como se fosse uma soma ou subtrao, ou seja, usa dois registradores e
coloca o resultado em um terceiro registrador do banco de registradores.
Esta multiplicao realizada normalmente e o resultado esperado ocorre
com 64 bits. A, somente os 32 bits menos significativos so transferidos para
o registrador especificado. A instruo mul deve ser usada com cuidado,
pois os valores de HI e LO so imprevisveis (dependem da implementao
do hardware multiplicador) e os resultados s apresentam alguma semntica
se os operandos forem nmeros pequenos, cujo resultado da multiplicao
caiba em 32 bits. Estas restries normalmente so verificadas em nossos
softwares, ou seja, o multiplicando e multiplicador costumam produzir
resultados menores que os 32 bits ofertados pelo hardware, mas os casos
especficos devem ser tratados pelo programador. A sintaxe de mul est
explicitada no exemplo a seguir.
mul $8, $9, $10
# $8 = $9 x $10
Como as demais instrues de multiplicao, mul no gera exceo quando

ocorre overflow.
29
29
A diviso a prxima operao a ser estudada. Existem duas

instrues de diviso no MIPS, uma para nmeros sinalizados e outra para
nmeros no sinalizados. Como sabemos quando realizamos uma operao
de diviso inteira (e/ou natural), existem dois resultados, o quociente e o
resto. Diferentemente da multiplicao, quando dividimos duas quantidades
de 32 bits, no podemos garantir que quociente e/ou resto sejam quantidade
representveis com menos de 32 bits. Assim, no MIPS, usamos o mesmo par
LO, HI para guardar o quociente e o resto da diviso de dois nmeros,
respectivamente. As instrues seguem a sintaxe do exemplo a seguir:
div $8, $9
divu $8, $9
# HI = $8 mod $9, LO = $8 div $9

# HI = $8 mod $9, LO = $8 div $9
Categoria
Nome
Exemplo
Operao
Comentrios
add
sub
add $8, $9, $10

sub $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addi
addi $8, $9, 40
$8 = $9 + 40
addu
subu
addu $8, $9, $10

subu $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addiu
addiu $8, $9, 40
$8 = $9 + 40
mul
mul $8, $9, $10
$8 = $9 x $10
mult
multu
mult $9, $10

multu $9, $10
div
div $9, $10
divu
divu $9, $10
HI,LO = $9 x $10
HI,LO = $9 x $10
HI = $9 mod $10
LO = $9 div $10
HI = $9 mod $10
LO = $9 div $10
Overflow gera exceo

Overflow gera exceo
Overflow gera exceo
entre 32.768 e +32.767
entre 0 e 65.535
HI, LO imprevisveis aps a
operao
Aritmtica

A viso do software
div opera sobre nmeros sinalizados e divu sobre nmeros no

sinalizados. div e divu simplesmente no geram qualquer tipo de exceo
de overflow, cabendo mais uma vez ao programador garantir que os
resultados so apropriados para os tamanhos especificados. Se o divisor for
um valor igual a zero o resultado imprevisvel. Nenhuma exceo gerada
sob esta circunstncia. O programador deve sempre checar se a operao
tem um divisor igual a zero e avisar ao usurio caso isto ocorra.
Chegamos ento ao fim das instrues aritmticas. A Tabela 2.2
mostra agora o compndio do que foi estudado.
30
Uma outra classe muito parecida com as operaes aritmticas a

classe das operaes lgicas. De fato, as operaes lgicas so bastante
conhecidas em HLLs. Uma operao or sobre dois operandos realiza o ou
bit-a-bit. Por exemplo:
or $8, $9, $10
$8 = $9 or $10
se $9 contm 0001 1001 1111 0000 0000 1111 0011 11002 e

$10 contm 1111 1101 1111 1110 0000 1111 1100 11002, ento o resultado
ser, em $8, 1111 1101 1111 1110 0000 1111 1111 11002.
As operaes, and, xor e nor seguem a mesma sintaxe. Existem
tambm operaes lgicas envolvendo valores imediatos. Ns j
mencionamos que quando operamos com valores imediatos, um dos
operandos especificado em 16 bits dentro da codificao da instruo.
Ento vamos verificar como podemos operar com um dos operandos em 16
bits e o outro em 32bits. Vamos ver o caso do andi. Esta instruo realiza
um and entre o valor em um registrador e o valor imediato especificado na
instruo. Assim, por exemplo:
andi $8, $9, 121
$8 = $9 and 121.
Se $9 contm 0001 1001 1111 0000 0000 1111 0011 11002 ento vamos
verificar a codificao binria de 121 = 111 10012 e transform-la em um
valor de 32 bits acrescentando zeros esquerda. A operao seria ento:
A viso do software
0001 1001 1111 0000 0000 1111 0011 11002 and

0000 0000 0000 0000 0000 0000 0111 10012, cujo resultado seria:
0000 0000 0000 0000 0000 0000 0011 10002
A operao ori tambm segue a mesma idia, acrescentando zeros

esquerda para completar os 32 bits necessrios operao na ALU.
As ltimas operaes lgicas a serem estudadas so as de
deslocamento esquerda e direita. A instruo sll(shift left logical)
desloca o contedo de um registrador em n posies esquerda,
acrescentando zeros direita. Vamos ver um exemplo com sll.
sll $9, $8, 6
$9 = $8 << 6.
31
31
Desejamos deslocar o contedo do registrador $8 de 6 posies esquerda.

Supondo que originalmente o valor em $8 1001 1001 1111 0000
0000 1111 0011 11002. Ento:
$8 =
1001 1001 1111 0000 0000 1111 0011 11002
1001 1001 1111 0000 0000 1111 0011 1100 0000002 ($8 deslocado)
0111 1100 0000 0011 1100 1111 0000 00002 (resultado em $9)
Um detalhe no exemplo acima mostra que os 6 bits mais significativos

de $8 foram descartados no resultado final.
A instruo sll muito usada para substituir multiplicaes. J
mencionamos que a multiplicao um processo caro em termos de
desempenho da mquina. O deslocamento para esquerda de uma casa
binria significa a multiplicao por dois da quantidade armazenada. Se a
quantidade a ser deslocada for de 3 casas binrias, estaremos efetivamente
multiplicando a quantidade por 8. A regra ento valor do multiplicando =
2n, onde n a quantidade de casas a ser deslocada para esquerda.
Quando realizamos multiplicaes desta forma temos de controlar o
overflow, j que as ltimas casas binrias (mais esquerda) so perdidas
durante a operao. Outra observao importante que s podemos realizar
multiplicaes com sll quando o multiplicador for uma potncia de 2, j
que deslocamos uma certa quantidade de casas binrias para esquerda.
Vamos agora mostrar um exerccio onde esta ltima restrio
diminuda, desde que o multiplicando esteja na circunvizinhana de uma
potncia de 2.
Desejamos implementar no MIPS um trecho de cdigo que seja capaz
de realizar uma multiplicao por um nmero que difere de uma potncia de
2 em apenas 3 unidades (a mais). Como podemos realizar isto com as
instrues conhecidas at o momento?
Bem, o problema realizar a seguinte operao:
R = A x B, onde B est na circunvizinhana de C, que uma potncia
de 2. Ento,B = C + 3, o que implica em R = A x (C + 3). Assim,
R = A.C + 3.A, ou R = A.C + A + A + A. Ora, A.C podemos realizar com
sll e a soma A + A + A pode ser feita com trs operaes de soma.
Para tornar claro, vamos pr alguns valores. Desejamos R = 50 x 19.
Ento, sendo 19 = 16 + 3, podemos realizar a operao como
R = 50x(16 + 3). Isto implica em R = 50x16 + 50x3 = 50x24 + 50 + 50 + 50.
A viso do software
$9 =
32
Vamos agora associar as variveis aos registradores. Supondo A em $8, B

em $9 e R em $10. Fazemos
sll
add
add
add
$10,
$10,
$10,
$10,
$8, 4
$10, $8
$10, $8
$10, $8
#
#
#
#
$10
$10
$10
$10
=
=
=
=
$8
$8
$8
$8
<< 4. $10 = $8 x 16
x 16 + $8
x 16 + $8 + $8
x 16 + $8 + $8 + $8
Isto pode parecer muito ineficiente j que a multiplicao poderia ser

realizada com apenas uma instruo mul $10, $8, $9. O problema que esta
instruo demora 10 vezes mais para ser executada que uma soma ou
deslocamento. Neste caso estaramos trocando 10 unidades de tempo (para
executar a multiplicao) por 4 unidades de tempo (para executar as 4
operaes). O cdigo fica ento muito mais eficiente, embora fique maior.
O oposto instruo sll a instruo srl (shift right logical). Ela
realiza o deslocamento de um valor armazenado em um registrador para a
direita, preenchendo com zeros os valores esquerda do nmero. Por
exemplo:
srl $9, $8, 6
$9 = $8 >> 6.
Desejamos deslocar o contedo do registrador $8 de 6 posies direita.

Supondo que originalmente o valor em $8 1001 1001 1111 0000
0000 1111 0011 11002. Ento:
A viso do software
$8 = 1001 1001 1111 0000 0000 1111 0011 11002

000000 1001 1001 1111 0000 0000 1111 0011 11002 (deslocado)
$9 = 0000 0010 0110 0111 1100 0000 0011 11002 (resultado em $9)
Mais uma vez temos de nos preocupar com os bits mais direita, que
so perdidos durante a execuo da instruo. A instruo srl
interessante para realizar divises de nmeros no sinalizados, ao molde do
que acontece com o sll.
Uma restrio substituio de uma instruo de diviso por uma de
deslocamento direita quanto utilizao de nmeros sinalizados. Ora,
sabemos que o bit de sinal o mais esquerda em um nmero binrio. Ento
ele precisaria ser replicado esquerda para manter o sinal ao final da
operao. Esta limitao levou ao projeto de mais uma instruo: sra (shift
33
33
right arithmetic). sra opera da mesma forma que srl, mas ao contrrio
desta ltima, os bits que sero adentrados esquerda so a rplica do bit de
sinal: O para um valor positivo e 1 para um valor negativo. Vamos ao
exemplo: desejamos deslocar o contedo do registrador $8 de 6 posies
direita, mantendo o sinal. Supondo que originalmente o valor em $8 1001
1001 1111 0000 0000 1111 0011 11002. Ento:
$8 = 1001 1001 1111 0000 0000 1111 0011 11002
111111 1001 1001 1111 0000 0000 1111 0011 11002 (deslocado)
$9 = 1111 1110 0110 0111 1100 0000 0011 11002 (resultado em $9)
Veja que a quantidade a ser deslocada um nmero negativo e por isto

os bits que completaram o $9 esquerda foram uns e no zeros.
Fechamos ento o bloco das operaes lgicas, compendiadas na
Tabela 2.3.
Categoria
Nome
Exemplo
Operao
Comentrios
lgicas
or
and
xor
nor
andi
ori
sll
srl
sra
or $8, $9, $10

and $8, $9, $10
xor $8, $9, 40
nor $8, $9, $10
andi $8, $9, 5
ori $8, $9, 40
sll $8, $9, 10
srl $8, $9, 5
srl $8, $9, 5
$8 = $9 or $10
$8 = $9 and $10
$8 = $9 xor 40
$8 = $9 nor $10
$8 = $9 and 5
$8 = $9 or 40
$8 = $9 << 10
$8 = $9 >> 5
$8 = $9 >> 5
Imediato em 16 bits
Imediato em 16 bits
Desloc. 32
Desloc. 32
Desloc. 32, preserva sinal
2.4 A viso do software transferncia de dados

J temos o conhecimento necessrio para realizar as operaes
aritmticas no MIPS. Entretanto, duas questes ficaram no ar na seo
anterior. Trata-se de como movimentar os dados do par de registradores HI,
LO para o banco de registradores ou como movimentar dados do banco
de/para memria. A primeira questo bem simples de responder, ento
vamos comear por ela.
O conjunto de instrues do MIPS apresenta duas instrues
especializadas no transporte dos contedos dos registradores HI e LO para o
banco de registradores: mfhi (Move From HI) e mflo (Move From LO).
A viso do software
34
Estas instrues apresentam apenas um operando: o registrador de destino.

A sintaxe demonstrada no exemplo a seguir.
mfhi $9
mflo $9
#
#
$9 = HI
$9 = LO
A viso do software
Os nomes so intuitivos, mas para deixar claro, mfhi, transfere o contedo

do registrador HI para o registrador de destino especificado na instruo,
enquanto, mflo, transfere o contedo do registrador LO para o registrador
de destino especificado. Estas instrues podem ser teis para controlar o
overflow das operaes de multiplicao e para podermos extrair o
quociente e o resto de uma diviso.
Agora vamos partir para a segunda questo. Sabemos que programas
em HLLs podem apresentar infinitos dados para serem utilizados durante a
execuo do cdigo. Sabemos tambm que o banco de registradores uma
regio limitada, portando normalmente at 18 variveis por vez. Ora,
imagine o caso onde um vetor de 128 posies fosse um dos dados a ser
utilizado no programa. Sem dvidas que haveria uma restrio enorme se
no fosse a memria.
Ns vamos estudar os detalhes da implementao da memria no
Captulo 6, mas precisamos de um modelo que ser utilizado pelo software
como sendo este repositrio de dados e programas. Ento, o software
enxerga a memria como um grande vetor onde cada posio indicada por
um endereo. Os endereos so seqenciais e numerados de 0 a
4.294.967.295. Cada byte ocupa uma destas posies. A Figura 2.1 mostra
como so os endereos e dados em uma memria. Os dados esto
representados em binrio e os endereos em hexadecimal.
endereos
dados
00000000h 10010000
00000001h 00010110
00000002h 01100000
00000003h 00000000
00000004h 11111111
00000005h 01100110
00000006h 01101110
00000007h 00110000
...
...
ffffffffh 00001011
Figura 2.1: Modelo de Memria
35
35
Todos os endereos so especificados em 32 bits (4 bytes). Para

acessar uma varivel na memria preciso ento informar qual o seu
endereo e para onde (qual registrador) ela deve ser transferida. No caso de
escrita na memria, o processo invertido. preciso especificar o endereo
de destino e qual o registrador que contm o dado a ser gravado naquele
endereo da memria.
Ento significa que ns estamos transferindo dados na memria que
esto organizados em bytes para registradores que utilizam 32 bits (uma
palavra de 4 bytes). Trs tamanhos de dados podem ser carregados para os
registradores: byte (8 bits), meia-palavra (16 bits) e palavra (32 bits).
Considerando que cada registrador comporta uma palavra inteira de 32 bits,
vamos mostrar como feita a transferncia de dados de uma palavra na
memria para um registrador e vice-versa. A Figura 2.2 estende a
compreenso da Figura 2.1. Cada palavra ocupa 4 posies na memria e
portanto palavras subseqentes esto 4 unidades de endereo a seguir. Assim
a memria pode ser enxergada como um grande repositrio de dados de 32
bits. Esta organizao da memria bastante comum nos processadores
modernos. Embora possamos enderear bytes, a transferncia feita em
palavras.
Nesta organizao no possvel transferir um valor de 32 bits que
tenha seu incio em um endereo diferente de um mltiplo de 4. Uma tentativa
de transferir uma palavra comeando de um endereo cujo ltimo nibble (
direita) seja diferente de 0, 4, 8 ou 12 (ch) gera uma exceo e o
processamento pra.
dados
00000000h 10010000
00000001h 00010110
00000002h 01100000
00000003h 00000000
00000004h 11111111
00000005h 01100110
00000006h 01101110
00000007h 00110000
...
...
ffffffffh 00001011
endereos
palavra 0
palavra 1
...
00000000h
00000004h
00000008h
0000000ch
00000010h
00000014h
00000018h
0000001ch
dados
10010000000101100110000000000000
11111111011001100110111000110000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
...
...
fffffffch 00000000000000000000000000001011
Figura 2.2: Modelo de Memria
J mencionamos que para transferir um dado da memria para o

banco de registradores preciso especificar o seu endereo efetivo. Para
A viso do software
endereos
36
tanto, o MIPS usa um clculo de endereo. Basicamente so utilizados um

registrador que fornece um endereo base e um imediato, especificado na
instruo, que fornece o deslocamento a partir deste endereo base. Este
modo de endereamento, com base e deslocamento, tem uma razo bastante
significativa: acessos a vetores.
Vamos conhecer as instrues de transferncia de palavras utilizadas
pelo MIPS. A instruo lw, load word, transfere dados da memria para o
banco de registradores e a instruo sw, store word, transfere dados do
banco de registradores para a memria. A Figura 2.3 mostra as duas
instrues de forma pictorial.
Banco de Registradores
registrador
Memria
dados
0
1
2
3
90166000
ff666e30
31
0000000b
...
endereos
lw
sw
00000000h
00000004h
00000008h
0000000ch
00000010h
00000014h
00000018h
0000001ch
...
dados
90166000
ff666e30
00000000
00000000
00000000
00000000
00000000
00000000
...
fffffffch 0000000b
A viso do software
Figura 2.3: Instrues de transferncia de dados
O clculo do endereo efetivo para acesso memria, ns j

mencionamos. Vamos agora elaborar a idia. Na sintaxe da instruo lw,
devem ser especificados um registrador de destino, e um par, registrador
base mais um deslocamento imediato. O valor armazenado no registrador
base somado ao valor imediato especificado na instruo formando assim o
endereo onde se encontra o dado na memria. Este endereo ento lido e o
dado carregado para dentro do banco de registradores, para o registrador
especificado na instruo. O clculo do endereo efetivo pode ser visto na
Figura 2.4. Neste exemplo o registrador escolhido foi o registrador 2 que
contm o seguinte dado: 0ch. O valor do deslocamento 4, assim o endereo
efetivo 0ch + 4h = 10h. O dado que est neste endereo carregado para o
registrador $30, especificado na instruo.
37
37
registrador
Memria
lw $30, 4($2)
lw reg_dest, desloc(reg_base)
dados
0 90166000
1 ff666e30
2 0000000c
3
...
endereos
0000000c
00000000h
00000004h
00000008h
0000000ch
00000010h
00000014h
00000018h
0000001ch
30 0000000f
31 0000000b
...
dados
90166000
ff666e30
00000000
00000000
0000000f
00000000
00000000
00000000
...
fffffffch 0000000b
Figura 2.4: Clculo do endereo efetivo
Para o caso de uma instruo sw, o clculo do endereo efetivo

exatamente igual. A Figura 2.5 mostra um exemplo de sw. A nica alterao
aqui diz respeito ao sentido da transferncia dos dados, que saem agora do
banco de registradores e vo para memria.
registrador
dados
0 90166000
1 ff666e30
2 0000000c
3
...
30 fffffff0
31 0000000b
Memria
sw $30, 4($2)
sw reg_fonte, desloc(reg_base)
4
0000000c
endereos
00000000h
00000004h
00000008h
0000000ch
00000010h
00000014h
00000018h
0000001ch
...
dados
90166000
ff666e30
00000000
00000000
fffffff0
00000000
00000000
00000000
...
fffffffch 0000000b
Figura 2.5: Clculo do endereo efetivo
Ento, neste momento ns conhecemos as instrues de transferncia

de dados, do tamanho de uma palavra, da memria para o banco de
registradores e vice-versa. Resta saber como estas palavras de dados,
associadas a variveis vo parar na memria. Via de regra, quando
declaramos as variveis de um programa o compilador cuida para alocar
espao na memria correspondente aos dados. Por exemplo, se declaramos 3
inteiros, a, b e c, na memria so reservados 3 endereos consecutivos para
A viso do software
38
guardar estas variveis. Quando inicializamos uma varivel durante sua

declarao, os endereos correspondentes na memria j devem ter seus
valores setados.
Um ponto crtico que merece nossa ateno a alocao de memria
para vetores e matrizes. Um vetor de nmeros inteiros ocupa tantas posies
na memria, quantos forem os seus dados. Por exemplo, vamos ver como a
memria alocada para as seguintes declaraes de dados: um inteiro no
sinalizado, x, inicializado com valor 3, um inteiro y, inicializado com -1 e um
vetor de inteiros n com 10 posies. A Figura 2.6 mostra a alocao
convencional de dados para este exemplo. Veja que os dados foram alocados
em uma regio de memria iniciando no endereo 0. Esta regio indiferente
para o programador, j que ele acessa a varivel pelo nome, mas, de fato, ela
controlada pelo mdulo carregador do Sistema Operacional.
As variveis so ento alocadas em seqncia, da forma como foram
declaradas. Observe que o vetor n tem um endereo de incio, tambm
chamado endereo base e os seus dados podem ser acessados a partir deste
endereo. Por exemplo, para acessar o dado n[0] usamos o endereo base de
n somado a zero. Para acessar o dado de n[1] usamos o endereo base de n
somado ao valor 4 (4x1) para encontramos o endereo efetivo. Para acessar
n[2] somamos o endereo base de n com 8 (4x2). Para acessarmos o dado
n[m] somamos o endereo base de n com 4 x m. Isto mostra todo potencial do
clculo do endereo efetivo presente na instruo de carga lw.
A viso do software
...
unsigned int x = 3;
int y = -1;
int n[10];
...
endereos
00000000h
00000004h
00000008h
0000000ch
00000010h
00000014h
00000018h
0000001ch
00000020h
00000024h
00000028h
0000002ch
...
Memria
dados variveis
x
00000003
y
ffffffff
00000000
n[0]
00000000
n[1]
00000003
n[2]
00000000
n[3]
00000000
n[4]
00000004
n[5]
00000000
n[6]
00000000
n[7]
00000000
n[8]
00000000
n[9]
...
...
Figura 2.6: Alocao de variveis na memria
Vamos fazer um outro exemplo de clculo para expresso:

n[3] = y * n[5];
39
39
Ora, a codificao em assembly para esta organizao de memria

seria:
#
#
#
#
#
carrega o valor de y em $8
carrega o endereo base de n em $9
carrega o valor de n[5] em $10
multiplica y por n[5]. Resultado em $8
guarda valor da multiplicao em n[3]
Neste exemplo utilizamos um registrador que ainda no havamos

trabalhado: o $0. Este registrador tem uma caracterstica especial, o valor
dele sempre zero, independente das instrues que operam com ele. Este
registrador muito importante para calcularmos valores iniciais de
endereos e/ou dados. Este cdigo precisaria ser alterado se a memria fosse
re-endereada (relocada), ou seja, se o incio dos dados no fosse no
endereo 0.
No caso de armazenamento de matrizes, o compilador enxerga uma
matriz como um vetor de vetores, portanto, as linhas so postas
seqencialmente na memria. Fica como exerccio descobrir como enderear
um elemento n[m,k] de uma matriz de nmeros inteiros.
At o presente mostramos como transportar dados de/ para memria.
Existe uma outra instruo, que pode ser interpretada tambm como uma
instruo lgica, que auxilia no clculo de endereos efetivos. Trata-se da
instruo lui (Load Upper Immediate). Esta instruo carrega na parte
mais significativa (16 bits mais esquerda) um valor imediato especificado
na prpria instruo e zera a parte baixa do registrador de destino. Por
exemplo, desejamos armazenar o endereo base de um vetor que comea em
0f3c0004h. Ora, no existe uma forma de armazenar imediatamente os 32 bits
que formam este endereo, pois todas as instrues que operam com
imediatos s admitem valores de 16 bits.
A soluo usar uma instruo que compute este endereo base por
partes. A instruo lui ento pode ser usada para armazenar a parte alta do
endereo e uma instruo de ori pode ser usada para armazenar a parte
baixa. A soluo para este exemplo seria:
lui $8, 0x0f3c # carrega a parte alta de $8 com 0x0f3c
ori $8, $8,0x0004 # ajusta a parte baixa do endereo
Ora, a primeira instruo armazena em $8 o valor 0f3ch nos 16 bits

mais significativos (mais esquerda). Os 16 bits menos significativos so
A viso do software
lw $8, 4($0)
addi $9, $0, 8
lw $10, 20($9)
mul $8, $8, $10
sw $8, 12($9)
40
zerados. Depois feito um or imediato com o valor 4, o que nos permite

construir o endereo base final do vetor, como mostrado a seguir.
0000 0000 0000 0000 0000 1111 0011 11002 (0x0f3c)
$8 =
0000 1111 0011 1100 0000 0000 0000 00002 (depois do lui)
0000 0000 0000 0000 0000 0000 0000 01002 (4)
0000 1111 0011 1100 0000 0000 0000 01002 (depois do ori)
Fechamos ento o bloco das operaes de transferncia de dados com

as instrues apresentadas na Tabela 2.4.
Categoria
Transferncia
de dados
Nome
Exemplo
Operao
mfhi
mflo
lw
sw
mfhi $8
mflo $8
lw $8, 4($9)
sw $8, 4($9)
$8 = HI
$8 = LO
$8 = MEM[4 + $9]
MEM[4 + $9] = $8
lui
lui $8, 100
$8 = 100 x 216
Comentrios
Carrega constante na poro

alta do registrador de
destino.
Zera a parte baixa.
Tabela 2.4: Instrues de transferncia de dados do MIPS
A viso do software
2.5 A viso do software suporte deciso

Uma das caractersticas mais importantes de uma linguagem de alto
nvel a possibilidade de escolha de trechos de cdigo para serem
executados em detrimento de outros, escolha esta controlada por uma
expresso lgica. A referncia explcita aqui das construes condicionais,
if then e if then else. Para construir estruturas condicionais no MIPS
preciso antes conhecer como realizada a execuo de um cdigo na
memria.
O conceito de programa armazenado, apresentado no captulo
precedente, o fundamento de nossa discusso. Na memria de um
computador no apenas os dados ficam armazenados, mas tambm os
programas. A memria dividida logicamente em regies de dados e de
cdigos. Esta diviso meramente uma conveno. Estudaremos o modelo
completo no captulo sobre o sistema de memrias. Por enquanto vamos
41
41
visualizar um diagrama que mostra os dados e os cdigos nas duas regies

de memria convencionadas para conter dados e programas. A Figura 2.7
apresenta a regio de cdigo como alocada entre os endereos 00400000h
e 0ffffffch. Nesta regio fica guardada a codificao binria (aqui
representada em hexadecimal por razes de simplicidade) das instrues. O
programa associado est apresentado ao lado apenas por razes
pedaggicas. Perceba que cada instruo ocupa necessariamente uma
palavra na memria.
A regio compreendida entre os endereos 10000000h e 10007ffch
guarda os dados. Neste caso, as mesmas variveis que utilizamos no exemplo
anterior, mas agora alocadas em sua regio mais convencional.
Regio
de
Cdigos
Regio
de
Dados
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
0ffffffch
10000000h
10000004h
10000008h
1000000ch
10000010h
...
10007ffch
10008000h
10008004h
10008008h
...
significado
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
lui $8, 0x1000

lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
00000000
00000003
ffffffff
00000000
00000000
00000003
...
x
y
n[0]
n[1]
n[2]
...
instrues
variveis
fffffffch
Figura 2.7: Alocao de variveis/instrues na memria
O programa a ser executado olhado seqencialmente, instruo

seguida de instruo. Como exerccio, descubra o que faz o cdigo
apresentado na Figura 2.7 e qual a situao da memria aps sua execuo.
J vimos que os dados para serem manipulados (computados)
precisam ser carregados para o banco de registradores. Os cdigos tambm
precisam ser carregados em um registrador. Existe um registrador especial
chamado IR (Instruction Register) que guarda a instruo que deve ser
A viso do software
Memria
Dados /
endereos
instrues
42
executada em um determinado instante. Vimos tambm que para acessar um

dado na memria preciso calcular o endereo onde ele se encontra. Para o
cdigo, usamos um registrador especial chamado PC (Program Counter).
Quando estamos executando um programa, o PC contm o endereo da
instruo a ser executada. Ela ento lida da memria e executada na via de
dados. O PC deve ser iniciado sempre com o valor 00400000h, pois este
endereo onde a regio de cdigo comea. A Figura 2.8 mostra os passos
para execuo de uma instruo de um programa.
Memria
dados /
endereos
instrues
PC
00400000
IR
3c081000
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
instrues
lui $8, 0x1000
lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
0ffffffch 00000000
...
...
Execuo da instruo
lui na via de dados
A viso do software
Figura 2.8 Execuo de uma instruo de um programa
Como as instrues so executadas seqencialmente, o valor de PC

tambm incrementado seqencialmente. Observe, entretanto, que uma
instruo ocupa 32 bits na memria e por isto a prxima instruo est 4
unidades de endereo (bytes) distante. Isto implica que o valor de PC
incrementado de 4 em 4. A Figura 2.9 mostra o restante da execuo do
cdigo.
Veja que o valor de PC fundamental para execuo do cdigo. Se o
valor de PC sair de sua seqncia natural vai provocar um descontrole na
seqncia de execuo das instrues. exatamente este o efeito que
precisamos para implementar instrues que saltem de um local para outro
do cdigo permitindo fazer uma escolha condicional.
Vamos aprender ento as instrues que alteram o valor de PC
condicionalmente ou no.
43
43
Memria
dados /
endereos
instrues
IR
8d090004
Execuo da instruo
lw na via de dados
PC
00400008
IR
8d0a0010
Execuo da instruo
lw na via de dados
PC
0040000c
IR
712a0002
Execuo da instruo
mul na via de dados
PC
00400010
IR
ad090008
Execuo da instruo
sw na via de dados
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
lui $8, 0x1000

lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
0ffffffch 00000000
...
...
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
lui $8, 0x1000

lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
0ffffffch 00000000
...
...
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
lui $8, 0x1000

lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
0ffffffch 00000000
...
...
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
3c081000
8d090004
8d0a0010
712a0002
ad090008
...
lui $8, 0x1000

lw $9, 4($8)
lw $10, 16($8)
mul $9, $9, $10
sw $9, 8($8)
...
0ffffffch 00000000
...
...
Figura 2.9 Execuo de um programa passo a passo
A viso do software
PC
00400004
00000000h
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
instrues
44
Vamos comear com as instrues bne e beq. bne salta para um

determinado endereo se os contedos dos dois registradores especificados
nos operandos no forem iguais (branch if not equal).
beq, seu
complemento, salta para um determinado endereo se os registradores
especificados em seus operados forem iguais (branch if equal). Para evitar a
necessidade de clculo de endereos de destinos usamos smbolos para
represent-los. Estes smbolos so associados a endereos atravs do uso de
rtulos.
O exemplo a seguir mostra uma estrutura if-then sendo
implementada com a instruo bne. As variveis i, j e h esto associadas a
$8, $9 e $10 respectivamente. O smbolo sai representa o endereo para
onde saltaremos caso a condio de igualdade no se verifique. A condio
do if para que a soma se realize que os valores de i e j sejam idnticos.
Se i e j no forem iguais iremos saltar a soma (h = i + j) sem executla. justamente esta ltima assertiva que implementamos no MIPS.
bne $8, $9, sai, verifica se o contedo de $8 igual ao contedo de
$9. Caso eles no sejam iguais, a instruo bne altera o valor de PC para
que ele salte para o endereo associado ao smbolo sai. A Figura 2.10
mostra como um compilador traduziria o if em um conjunto de instrues
em assembly do MIPS e ainda, qual o fluxograma das aes esperadas,
quando verificada a expresso lgica de (des)igualdade.
A viso do software
if (i == j){
h = i + j;
}
sai:
bne $8, $9, sai

add $10, $8, $9
....
no
i=j
sim
h=i+j
Figura 2.10 Implementao de um comando if em MIPS
Vamos agora verificar como estes comandos so alocados na memria

e executados no processador. A Figura 2.11 mostra o momento em que a
instruo bne executada. Ela verifica os valores dos registradores $8 e $9
45
45
e percebe que eles so diferentes. A instruo altera o valor de PC para que

ele enderece o rtulo sai. A execuo segue normalmente depois, com o PC
sendo alterado de 4 em 4 unidades.
A Figura 2.12 tambm mostra a execuo da instruo bne, mas neste
caso os registradores $8 e $9 contm o mesmo valor. Isto significa que a
instruo bne no interfere no curso natural do PC, que passa a apontar a
instruo de soma. Aps execut-la o valor de $10 alterado e o
processamento segue normalmente. A instruo nop mostrada nas figuras
uma instruo que no realiza nada.
Processador
...
$8 00000004
$9 00000003
$10 00000000
...
PC
00400000
Memria
dados /
endereos
instrues
instrues
00000000h
...
...
00400000h 15090002
00400004h 01095020
00400008h 00000000
...
...
bne $8, $9, sai

add $10, $8, $9
sai: nop
...
00000000h
...
...
00400000h 15090002
00400004h 01095020
00400008h 00000000
...
...
bne $8, $9, sai

add $10, $8, $9
sai: nop
...
PC
00400008
Figura 2.11 Execuo de um comando if (bne) no MIPS
A viso do software
...
$8 00000004
$9 00000003
$10 00000000
...
46
Processador
...
$8 00000004
$9 00000004
$10 00000000
...
PC
00400000
Memria
dados /
endereos
instrues
instrues
00000000h
...
...
00400000h 15090002
00400004h 01095020
00400008h 00000000
...
...
bne $8, $9, sai

add $10, $8, $9
sai: nop
...
00000000h
...
...
00400000h 15090002
00400004h 01095020
00400008h 00000000
...
...
bne $8, $9, sai

add $10, $8, $9
sai: nop
...
00000000h
...
...
00400000h 15090002
00400004h 01095020
00400008h 00000000
...
...
bne $8, $9, sai

add $10, $8, $9
sai: nop
...
...
$8 00000004
$9 00000004
$10 00000008
...
PC
00400004
...
$8 00000004
$9 00000004
$10 00000008
...
PC
00400008
A viso do software
Figura 2.12 Execuo de um comando if (bne) no MIPS
O MIPS tambm propicia saltos incondicionais. A instruo j (jump)

salta para um rtulo independente de qualquer condio de valores de
registradores. Esta instruo possui como operando apenas o endereo de
destino do salto. Ela til, entre outras coisas, para implementao da
estrutura condicional if-then-else. Veja que o bloco then quando terminado,
precisa sair do if incondicionalmente, sob pena de o comando executar o
then e o else seqencialmente. A Figura 2.13 mostra estrutura e a Figura
2.14 e 2.15 a execuo do trecho de programa.
if (i == j){
h = i + j;
} else {
h = i j;
}
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai:
nop
no
i=j
sim
h=i-j
h=i+j
Figura 2.13 Implementao de uma estrutura ifthenelse em MIPS
47
47
Processador
...
$8 00000004
$9 00000003
$10 00000000
...
PC
00400000
$8 00000004
$9 00000003
$10 00000001
...
PC
0040000c
$8 00000004
$9 00000003
$10 00000001
...
PC
00400010
Memria
dados /
endereos
instrues
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
Na Figura 2.14 o bne provoca uma alterao no PC, de tal forma que
a prxima instruo a ser executada a sub. Em seguida a execuo segue
seu curso normal. J a Figura 2.15 mostra a execuo do bloco then
finalizando com a instruo j. Quando esta ltima executada, ela altera o
valor do PC para que o mesmo aponte para o endereo do rtulo sai. Este
salto incondicional, no depende de nenhum valor de registrador.
Depois de executado o jump o fluxo de execuo segue normalmente.
At o presente aprendemos como construir estruturas condicionais e
como desviar o fluxo de execuo de um programa utilizando as instrues
bne, beq e j. Existe, entretanto, uma limitao de implementao de
estruturas condicionais de HLLs, com apenas estas instrues. Ora, e se a
condio de comparao envolver uma condio de maior-que ou menorque? Para suportar esta funcionalidade o conjunto de instrues do MIPS
tem uma instruo que pode ser considerada aritmtica, que opera
informando se um determinado valor menor que outro. Esta instruo a
slt (set on less then). Sua sintaxe exige a presena de dois operandos que
A viso do software
Figura 2.14 Execuo de uma estrutura if-then-else no MIPS
48
tero seu valores avaliados e de um operando destino, que ir receber o

valor 1 ou 0 dependendo se a condio de menor que for verificada.
Processador
...
$8 00000004
$9 00000004
$10 00000000
...
PC
00400000
$8 00000004
$9 00000004
$10 00000008
...
PC
00400004
$8 00000004
$9 00000004
$10 00000008
...
PC
00400008
$8 00000004
$9 00000004
$10 00000008
...
A viso do software
PC
00400010
Memria
dados /
endereos
instrues
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
49
49
Vamos a um exemplo:
slt $8, $9, $10 # se $9 < $10 ento $8 = 1, seno $8 = 0
Neste caso, a instruo verifica se $9 menor que $10, caso isto ocorra, o
valor de $8 setado (vira 1). Se $9 no for menor que $10 (ou seja, $9
maior ou igual a $10), ento $8 recebe o valor 0. Vejamos como podemos
implementar uma estrutura if-then-else cuja condio exige uma comparao
de grandeza. A Figura 2.16 mostra a combinao das instrues slt e beq
para implementar o if.
Veja que se i < j ento a instruo slt vai colocar em $11 o valor
1. A beq que vem logo em seguida vai verificar se $11 contm um valor 0. Se
tiver o 0 saltar para o rtulo else, seno executar a instruo seguinte, a
soma. Neste caso $11 contm 1 e portanto a soma ser executada. Este
exatamente o efeito procurado, se i < j a expresso a ser executada a
soma e no a subtrao. A Figura 2.17 ilustra tal situao.
slt $11, $8, $9

beq $11, $0, else
add $10, $8, $9
j sai
else: sub $10, $8, $9
sai:
nop
no
i<j
sim
h=i-j
h=i+j
Figura 2.16 Implementao de uma estrutura ifthenelse no MIPS
A Figura 2.18, por sua vez, mostra a situao contrria, onde $8 no

menor que $9. Isto ir fazer com que o bloco else (a subtrao) seja
executado.
A instruo slt faz a comparao com nmeros sinalizados,
entretanto, existe uma outra instruo, sltu, que opera com nmero no
sinalizados. preciso um cuidado especial para escolher qual das duas
instrues deve compor nossos cdigos. Uma escolha errada pode levar a
resultados inesperados.
A viso do software
if (i < j){
h = i + j;
} else {
h = i j;
}
50
Processador
$0 00000000
...
$8
$9
$10
$11
PC
00000004
00000005
00000000
00000001
...
00400000
Memria
dados /
endereos
instrues
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
$8, $9
$0 00000000
...
$8
$9
$10
$11
PC
00000004
00000005
00000000
00000001
...
00400004
$8, $9
$0 00000000
...
$8
$9
$10
$11
PC
00000004
00000005
00000009
00000001
...
00400008
$8, $9
$0 00000000
A viso do software
...
$8
$9
$10
$11
PC
00000004
00000005
00000009
00000001
...
0040000c
$8, $9
$0 00000000
...
$8
$9
$10
$11
PC
00000004
00000005
00000009
00000001
...
00400014
$8, $9
51
51
Processador
$0 00000000
...
$8
$9
$10
$11
PC
00000005
00000004
00000000
00000000
...
00400000
Memria
dados /
endereos
instrues
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
...
...
0109582a
11600003
01095020
08100005
01095022
00000000
...
slt $11,
beq $11,
add $10,
j sai
else: sub $10,
sai: nop
...
$8, $9
$0, else
$8, $9
$8, $9
$0 00000000
...
$8
$9
$10
$11
PC
00000005
00000004
00000000
00000000
...
00400004
$8, $9
$0 00000000
...
$8
$9
$10
$11
PC
00000005
00000004
00000001
00000000
...
00400010
$8, $9
$0 00000000
$8
$9
$10
$11
PC
00400014
$8, $9
Chegamos agora ao fim desta seo. As instrues de salto

condicionais e incondicionais mostradas podem realizar qualquer estrutura
de deciso de uma linguagem de alto nvel. Com elas tambm possvel
construir laos, sendo deixado para o leitor, como exerccio, construir
estruturas for, while, e repeat.
A viso do software
...
00000005
00000004
00000001
00000000
...
52
Categoria
Suporte a
deciso
Nome
Exemplo
bne
bne $8, $9, rotulo
beq
beq $8, $9, rotulo
J rotulo
slt
slt $10, $8, $9
sltu
sltu $10, $8, $9
Operao
se $8 $9 ento
PC endereo[rotulo]
se $8 = $9 ento
PC endereo[rotulo]
PC endereo[rotulo]
se $8 < $9
ento $10 1
seno $10 0
se $8 < $9
ento $10 1
seno $10 0
Comentrios
Opera com nmeros

sinalizados
Opera com nmeros
no sinalizados
Tabela 2.5: Instrues de suporte a deciso
2.6 A viso do software suporte procedimentos
A viso do software
Procedimento so pores de cdigo que realizam uma tarefa bem

especfica dentro de um programa. Digamos que um programa exija a
computao de um fatorial diversas vezes. Podemos escrever o cdigo
contendo os diversos trechos de computao do fatorial, como mostrado na
Figura 2.19. Este trecho de cdigo calcula o fatorial de um nmero
armazenado em $4 duas vezes. O resultado fica em $2. O valor de $4 setado
para 5 e em seguida o fatorial de 5 calculado, deixando o resultado, 120,
em $2. Em seguida $4 recebe o valor 9 e um novo clculo, agora para 9!,
realizado. Finalmente os dois fatoriais so somados. Veja que o trecho do
cdigo que calcula o fatorial est repetido no programa.
main:
fat1:
lab1:
addi $4,$0, 5
addi $8, $0, 1
mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab1
fimFat1: add $2, $8, $0
add $3, $2, $0
addi $4, $0, 9
fat2:
addi $8, $0, 1
lab2:
mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab2
fimFat2: add $2, $8, $0
add $3, $3, $2
Clculo do Fatorial
Clculo do Fatorial
Figura 2.19: Trecho de cdigo com clculos de fatoriais
53
53
A idia de criarmos um nico trecho que calcula o fatorial pode ser

bastante proveitosa (e econmica do ponto de vista do tamanho do
programa). Este trecho seria ento invocado pelo programa principal (que se
inicia no rtulo main) o quanto for necessrio. O trecho do clculo do
Fatorial seria nico em todo o programa e somente invocaes (call) a este
trecho ocorreriam dentro do programa principal. Ao Finalizar a execuo do
fatorial, o programa retornaria (ret) para o seu fluxo normal. A Figura 2.20
mostra o modelo de chamada e retorno do trecho que calcula o fatorial.
Clculo do Fatorial
main:
call1:
ret1:
call2:
ret2:
addi $4,$0, 5
call
ret
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
fimFat: add $2, $8, $0
add $3, $2, $0

addi $4, $0, 9
call
ret
add $3, $3, $2
Ns podemos ento chamar este trecho de clculo do fatorial, de um

procedimento, funo ou sub-rotina. Em programao de alto nvel, uma
funo difere de um procedimento pela presena ou no de um dado de sada.
Como o clculo de um fatorial retorna um valor, em HLL, o trecho seria
considerado uma funo. parte desta discusso, para ns, vamos chamar
de procedimento qualquer trecho de cdigo que tenha uma funcionalidade
especfica e que possa ser fatorado de um programa.
Como j sabemos como fazer desvios de fluxo com as instrues do
assembly do MIPS, poderamos tentar nos arvorar em implementar um
procedimento com os nossos conhecimentos atuais. Apesar de
mirabulosamente possvel, vamos nos deparar com um problema: quando o
procedimento terminar, preciso retornar para algum lugar no cdigo
principal e este lugar depende de onde o procedimento foi invocado. No
nosso exemplo da Figura 2.19, ao fim da execuo do trecho do fatorial
A viso do software
Figura 2.20: Trecho de cdigo com clculo de fatorial
54
poderamos retornar para duas posies possveis: ret1 ou ret2. Isto depende
de onde o procedimento foi invocado: de call1 ou call2. Uma soluo para o
problema seria guardar em algum lugar a identidade de quem chamou e no
momento do retorno, olhando para esta identidade, decidir para onde
retornar.
Para implementar esta funcionalidade o MIPS dispe de 2 instrues
de desvio especialmente projetadas para dar suporte a procedimentos: jal
(jump-and-link) e jr (jump register). jal uma instruo de
desvio incondicional como j, mas alm de alterar o valor do PC, ela tambm
guarda em $31 o endereo de retorno do procedimento. jr, por sua vez,
tambm uma instruo de desvio incondicional e retorna para o endereo
especificado no registrador usado na instruo. Se este registrador o $31,
ento ele retorna exatamente para o endereo associado posio de retorno
da chamada especfica do procedimento.
A Figura 2.21 mostra o trecho do cdigo alocado na memria. Observe
que o procedimento fatorial (fat), ser invocado pelo programa principal com
a instruo jal. O retorno do procediemento implementado com a
instruo jr especificando o seu operando como sendo o registrador $31.
Observe tambm que quando o programa alocado na memria o valor de
PC passa a apontar para o endereo associado ao rtulo main. Por isto,
qualquer de nossos cdigos precisa ter um rtulo main no seu incio.
Processador
$0 00000000
A viso do software
...
$2
$3
$4
$8
$31
PC
00000000
00000000
00000000
...
00000000
...
00000000
00400018
Memria
dados /
endereos
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
instrues
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
Figura 2.21: Implementao do procedimento fatorial
55
55
Agora vamos verificar como ocorre a execuo deste trecho de cdigo.

A Figura 2.22 mostra o incio da execuo. Veja que a instruo jal guarda
em $31 o endereo de retorno do procedimento, ao mesmo tempo em que vai
alterar o valor de PC para apontar para o endereo de incio do
procedimento.
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000000
00000000
00000005
...
00000000
...
00000000
00400018
$0 00000000
...
$2 00000000
$3 00000000
$4 00000005
...
$8 00000000
...
$31 00400020
PC
0040001c
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000000
00000000
00000005
...
00000001
...
00400020
00400000
Memria
dados /
endereos
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
instrues
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
Figura 2.22: Execuo do cdigo com procedimento fatorial
A viso do software
Processador
56
Depois de executado todo o procedimento, o resultado guardado em

$2 (78h = 120). Da acontece o retorno usando a instruo jr. Ao ser
executada ela pe em PC o valor guardado em $31. Isto faz com que a
execuo retorne para a instruo seguinte chamada do procedimento. A
Figura 2.23 ilustra a execuo deste trecho.
Processador
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000078
00000000
00000000
...
00000078
...
00400020
00400010
$0 00000000
...
$2
$3
$4
$8
$31
A viso do software
PC
00000078
00000000
00000000
...
00000078
...
00400020
00400014
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000078
00000078
00000000
...
00000078
...
00400020
00400020
Memria
dados /
endereos
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
instrues
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
57
57
Uma vez de volta ao programa principal o valor de $4 ajustado para

9. Em seguida a instruo jal mais uma vez invoca o procedimento fatorial.
Agora o valor guardado em $31 0040002ch, ou seja, o novo endereo de
retorno do procedimento. Ento o procedimento novamente executado.
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000078
00000078
00000009
...
00000078
...
00400020
00400024
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000078
00000078
00000009
...
00000078
...
0040002c
00400028
$0 00000000
...
$2
$3
$4
$8
$31
PC
00000078
00000078
00000009
...
00000001
...
0040002c
00400000
Memria
dados /
endereos
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
instrues
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
A viso do software
Processador
58
Ao fim de mais uma execuo do procedimento, a instruo jr altera o

valor de PC para o endereo de retorno, anteriormente guardado em $31.
quando retorna ao programa principal o novo valor de $2 contm o clculo
do fatorial de 9. Este valor ento somado ao valor que existia
anteriormente, propiciando o resultado final do programa: calcular 5! + 9!.
Processador
$0 00000000
...
$2
$3
$4
$8
$31
PC
00058980
00000078
00000000
...
00058980
...
0040002c
00400014
$0 00000000
...
$2 00058980
$3 000589f8
$4 00000000
...
$8 00058980
...
$31 0040002c
A viso do software
PC
0040002c
Memria
dados /
endereos
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
00400014h
00400018h
0040001ch
00400020h
00400024h
00400028h
0040002ch
...
...
20080001
71040002
2084ffff
1480fffe
01001020
03e00008
20040005
0c100009
00401820
20040009
0c100009
00621820
...
instrues
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
fat:
lab:
addi $8, $0, 1

mul $8, $8, $4
addi $4, $4, -1
bne $4, $0, lab
add $2, $8, $0
fimFat: jr $31
main:
addi $4,$0, 5
jal fat
add $3, $2, $0
addi $4, $0, 9
jal fat
add $3, $3, $2
Uma observao importante nesta execuo que o programador

definiu exatamente em qual registrador deve ser passado para o
procedimento o argumento de entrada, no nosso caso, o nmero sobre o qual
ser computado o fatorial. O registrador escolhido foi o $4. Tambm foi
acordado entre o procedimento e o programa principal, qual o registrador
que portaria o resultado da operao. O registrador escolhido foi o $2.
O MIPS convencionou que os registradores $4 a $7 devem ser usados
para passagem de parmetros para procedimentos. Tambm os registradores
59
59
$2 e $3 so usados, por conveno, para guardar resultados dos

procedimentos.
Sumarizando agora, temos as instrues de suporte implementao
de procedimentos no MIPS. A Tabela 2.6 mostra a instrues estudadas.
Categoria
Nome
Suporte a
procedimentos
Exemplo
jal
jal rotulo
jr
jr $31
Operao
Comentrios
$31 endereo[retorno]
PC endereo[rotulo]
PC $31
Tabela 2.6: Instrues de suporte procedimentos
2.7 Concluses
Conhecemos neste captulo algumas das principais palavras da
linguagem de montagem do MIPS. Como qualquer idioma, juntar as palavras
para formar uma frase, no nosso caso um programa, requer treino. Muito
treino. Decor-las de pouca valia por que o nosso interlocutor uma
mquina que s entende se as palavras estiverem corretas e as frases muito
bem formadas. O esperado que haja muito treino da parte do leitor que
queira, de fato, se apropriar deste conhecimento.
A Tabela 2.7 serve de gabarito, para ser utilizado enquanto voc no se
apropria inteiramente das palavras. Alm disto, ela tambm serve para voc
tirar dvidas da sintaxe da instruo, agindo como um pequeno dicionrio.
Aprendemos tambm que o cuidado para que um valor possa ser
armazenado, sem problemas de overflow, nos registradores de
responsabilidade do programador.
Vamos agora ver alguns detalhes adicionais. No MIPS h tambm um
conjunto de instrues, chamadas pseudo-instrues. Elas no existem de fato,
mas um programador pode utiliz-las desde que o seu montador oferea
suporte pseudo-instrues. Um exemplo mov $4, $8. (move. Mova o
contedo do registrador $8 para o registrador $4) O montador interpretaria
esta pseudo-instruo e geraria o cdigo de mquina correspondente a
add $4, $0, $8 ou or $4, $0, $8. Existem tambm pseudoinstrues que se desdobram em mais de uma, por exemplo,
bgt $8, $9, label (branch if grater then, salta para label se $8 for
maior que $9). O montador do MIPS geraria ento, em cdigo de mquina, a
seguinte seqncia de instrues: slt
$1,
$9,
$8 e
bne $1, $0, label. O efeito o mesmo pretendido.
60
Categoria
Nome
Exemplo
Operao
Comentrios
add
sub
add $8, $9, $10

sub $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addi
addi $8, $9, 40
$8 = $9 + 40
addu
subu
addu $8, $9, $10

subu $8, $9, $10
$8 = $9 + $10
$8 = $9 $10
addiu
addiu $8, $9, 40
$8 = $9 + 40
mul
mul $8, $9, $10
$8 = $9 x $10
mult
multu
mult $9, $10

multu $9, $10
div
div $9, $10
divu
divu $9, $10
or
and
xor
nor
andi
ori
sll
srl
sra
mfhi
mflo
lw
sw
or $8, $9, $10

and $8, $9, $10
xor $8, $9, 40
nor $8, $9, $10
andi $8, $9, 5
ori $8, $9, 40
sll $8, $9, 10
srl $8, $9, 5
srl $8, $9, 5
mfhi $8
mflo $8
sw $8, 4($9)
sw $8, 4($9)
HI,LO = $9 x $10
HI,LO = $9 x $10
HI = $9 mod $10
LO = $9 div $10
HI = $9 mod $10
LO = $9 div $10
$8 = $9 or $10
$8 = $9 and $10
$8 = $9 xor 40
$8 = $9 nor $10
$8 = $9 and 5
$8 = $9 or 40
$8 = $9 << 10
$8 = $9 >> 5
$8 = $9 >> 5
$8 = HI
$8 = LO
$8 = MEM[4 + $9]
MEM[4 + $9] = $8
Overflow gera exceo

Overflow gera exceo
Overflow gera exceo
Valor do imediato na faixa entre
32.768 e +32.767
Valor do imediato na faixa entre
0 e 65.535
operao
lui
lui $8, 100
$8 = 100 x 216
bne
bne $8, $9, rotulo
beq
beq $8, $9, rotulo
J rotulo
slt
slt $10, $8, $9
sltu
sltu $10, $8, $9
jal
jal rotulo
jr
jr $31
Aritmtica
lgicas
Transferncia
de dados
Suporte a
deciso
Suporte a
procedimentos
se $8 $9 ento
PC endereo[rotulo]
se $8 = $9 ento
PC endereo[rotulo]
PC endereo[rotulo]
se $8 < $9
ento $10 1
seno $10 0
se $8 < $9
ento $10 1
seno $10 0
$31
endereo[retorno]
PC endereo[rotulo]
PC $31

Imediato em 16 bits
Imediato em 16 bits
Desloc. 32
Desloc. 32
Desloc. 32. Preserva sinal
Carrega constante na poro alta

do registrador de destino.
Zera a parte baixa.
Opera com nmeros sinalizados
Tabela 2.7: Instrues do MIPS
Opera com nmeros

no sinalizados
61
O uso de pseudo-instrues fortemente desaconselhvel para

aprendizagem, porque a apropriao do conhecimento sobre as instrues
reais poderia ser prejudicada.
Ao longo deste captulo vimos que alguns registradores so utilizados
para funes especficas, por exemplo, $2 e $3 so usados para guardar os
resultados de procedimentos. Vimos a pouco o $1 sendo usado para
implementar uma pseudo-instruo. A fim de garantir uma certa
inteligibilidade a respeito do propsito de cada registrador, foram
convencionados nomes para cada um deles. $v0 a mesma coisa que $2, ou
seja, usado para guardar o valor de retorno de um procedimento. Como esta
poltica de uso universal possvel programar em assembly usando os
nmeros ou os nomes dos registradores. A Tabela 2.8 mostra os nomes e usos.
Nome do
Registrador
Nmero do
Registrador
$zero
$at
$v0
$v1
$a0
$a1
$a2
$a3
$t0
$t1
$t2
$t3
$t4
$t5
$t6
$t7
$s0
$s1
$s2
$s3
$s4
$s5
$s6
$s7
$t8
$t9
$kt0
$kt1
$gp
$sp
$fp
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$ra
31
Uso previsto
Constante ZERO
Reservado para tarefas do montador (assembler tasks)
Valores dos resultados dos procedimentos
Argumentos (parmetros) a serem passados para
procedimentos
Registradores que guardam valores temporrios
Registradores que guardam valores temporrios que

sero salvos de manipulao por procedimentos.
Mais temporrios
Reservados para tarefas do kernel do Sistema
Operacional (kernel tasks)
Apontador global (global pointer)
Apontador de pilha (stack pointer)
Apontador de quadros (frame pointer)
Endereo de Retorno de procedimentos
(return address)
Tabela 2.8: Nomes e atribuies de cada registrador do MIPS
62
Bom, resta-nos desejar bom trabalho, bons exerccios e boa diverso na

soluo dos problemas. A programao um mundo sem fronteiras, ento se
pode pensar nas mais variadas situaes para produo de programas.

A essncia deste captulo a prtica com simuladores. O SPIM um
simulador prprio para ns testarmos nossos programas. Ele tem um
interpretador de cdigo assembly do MIPS e um micro sistema operacional,
para suporte a funcionalidades muito bsicas.
Como j mencionamos, um programa composto de duas partes, as
variveis e os cdigos. Para fazer um programa inteligvel pelo SPIM
preciso declarar a regio que contem dados e a regio que contem cdigos.
Para isto usamos uma diretiva de montagem, que vem a ser uma instruo do
programador para o montador e no para sua ao de transformao do
cdigo. A diretiva .data especifica que deste ponto em diante, seguem-se os
dados. A diretiva .text especifica que deste ponto em diante, esto as
instrues propriamente ditas.
Um outro detalhe importante quando utilizamos o SPIM saber onde
ficam, por default, alocadas a regio de dados e de cdigos na memria. A
conveno do MIPS utilizada: cdigos comeam no endereo 00400000h e
dados em 10000000h.
Entretanto, um pequeno trecho de instrues do sistema operacional
que de fato est alocado no endereo 00400000h. Neste trecho existe uma
instruo jal main. Isto significa que o cdigo produzido pelo usurio vai
ficar alocado do endereo 00400024h em diante.
Tambm para os dados preciso tomar cuidado. Embora a regio
comece no endereo 10000000h, os dados especificados no seu programa vo,
de fato, ficar alocados a partir de 10010000h.
Para termos idia de um programa em assembly, pronto para ser
executado no MIPS, mostramos a seguir, na Figura 2.24, um cdigo que
promove a ordenao de um vetor. O Vetor est especificado na memria.
Veja que foi utilizada uma diretiva .word na regio de dados do programa.
.word indica que cada elemento do vetor ocupar uma palavra de 32 bits. Em
nossos exerccios vamos sempre utilizar dados de 32 bits. Um outro detalhe
que todos os elementos do vetor foram declarados em uma nica linha, mas na
prtica, cada um ocupar uma palavra na memria.
63

#The default address for the beginning of
#users data is 0x10010000 = 268500992
#(High=0x1001=4097 and Low=0x0000=0)
#
# This program performs vector ordering
# by EBWN on Sept 17, 2004 11h00
a:
n:
.data
.word -2, 20, -270, 15, 9, 62, 1, 8, -100
.word 9 # vector size (elements)
.text
#Every code begins with
main:
ori $8, $0, 0
ori $9, $0, 0
ori $10, $0, 0
lui $18, 4097
lw $17, 36($18)
addi $19, $17, -1
m1:
slt $18, $8, $19

beq $18, $0, m3
addi $9, $8, 1
"main" label
# i in $8
# j in $9
# min in $10
# n in $s1 ($17)
# n-1 in $s3 ($19)
# if i >= n-1 then quit
# j = i+1;
ori $18, $0, 4

mul $11, $8, $18
lui $18, 4097
add $15, $18, $11 # calculate address of a[i] (in $15)
lw $10, 0($15)
# load a[i] in $10
m4:
slt $18, $9, $17

beq $18, $0, m2
# if j >= n then exit loopint
ori $18, $0, 4

mul $11, $9, $18
lui $18, 4097
add $18, $18, $11 # calculate address of a[j] (in $18)
lw $12, 0($18)
# load a[j] in $12
slt $20, $12, $10 # if a[j] < a[i] swap a[j] with a[i]
beq $20, $0, dontswap
swap: sw $12, 0($15)
sw $10, 0($18)
add $10, $12, $0
dontswap:
addi $9, $9, 1
j m4
# j++
m2:
addi $8, $8, 1

j m1
# i++
m3:
nop
# this is the end
64
Agora, utilizar o simulador!
2.9 Exerccios
2.1
Pesquise na web e produza um resumo sobre como transferir dados de

tamanhos diferentes de uma palavra de e para o banco de registradores.
2.2 Pesquise na web e produza um resumo sobre big endian e little endian.
2.3 Pesquise na web e produza um resumo sobre pseudo-instrues do
MIPS.
2.4 Pesquise na web e produza um resumo sobre instrues privilegiadas
do MIPS.
2.5 Pesquise na web e produza um resumo sobre a instruo jalr do
MIPS.
2.6 Pesquise na web e produza um resumo sobre a instruo madd do
MIPS.
2.7 Pesquise na web e produza um resumo sobre a instruo msub do
MIPS.
2.8 Pesquise na web e produza um resumo sobre a instruo rotr do
MIPS.
2.9 Pesquise na web e produza um resumo sobre a instruo seh do MIPS.
2.10 Escreva um cdigo em linguagem de montagem para realizar a
expresso
a = b + c (d e) sem precisar utilizar mais de 5
registradores.
2.11 Por que no existe uma operao subi no MIPS?
2.12 Por que a instruo addiu $8, $9, -5 contm um erro de
semntica?
2.13 Crie uma seqncia de instrues MIPS para implementar a instruo
mod do C/Java.
2.14 Crie uma seqncia de instrues MIPS para implementar a instruo
div do C/Java.
2.15 Como implementar uma negao bit-a-bit no MIPS usando apenas uma
instruo?
2.16 Mostre como podemos fazer uma diviso de um nmero por outro sem
utilizar a instruo div ou divu.
2.17 Construir um cdigo em assembly do MIPS para executar o seguinte

cdigo em alto-nvel:
a = 1;
b = 2;
if (a<=b){
a= a + b;
}
cdigo em alto-nvel:
a = 1;
b = 2;
for (i = 0; i<10; i++){
a= a + b;
}
cdigo em alto-nvel:
a = 1;
b = 2;
for (i = 0; i<10; i++){
if (a < b){
a = a + 2;
}else{
b = b + 2;
}
}
cdigo em alto-nvel:
a = 1;
b = 2;
i = 0;
while (i<10){
if (a < b){
a++;
}else{
b++;
}
i++;
}
65
66
2.21 Construir um cdigo em assembly do MIPS para somar dois vetores;

2.22 Construir um cdigo em assembly do MIPS para ordenar um vetor
2.23 Um produto interno de dois vetores definido como:
n-1
prod_int =
ai x bi
i=0
onde ai o elemento de ndice i do vetor a

onde bi o elemento de ndice i do vetor b.
Fazer um programa em assembly do MIPS para calcular o produto
interno de dois vetores com 30 elementos.
2.24 Construir um cdigo em assembly do MIPS para somar duas matrizes 3
por 2.
2.25 Construir um cdigo em assembly do MIPS para multiplicar duas
matrizes quadradas de dimenses NxN
2.26 Construir um cdigo em assembly do MIPS para calcular uma matriz
transposta.
2.27 Construir um cdigo em assembly do MIPS para resolver um sistema
de equaes de trs variveis.
Captulo 3
Linguagem de
Mquina
3.1 Introduo
Neste captulo vamos conhecer melhor a tarefa do montador. Vamos, de
fato, conhecer o objeto que ele gera, a linguagem de mquina do MIPS. J
sabemos que existe uma correspondncia de um para um entre uma instruo
em linguagem de montagem e uma instruo em linguagem de mquina.
Sabemos tambm que no MIPS todas as instrues tm o mesmo tamanho: 32
bits.
Bem, para comearmos a conhecer a linguagem de mquina, vamos
abordar a converso da instruo add $8, $9, $10 em sua equivalente.
Os bits que formam a instruo so divididos em grupos que indicam a
operao a ser realizada e os operandos. No MIPS os 6 bits mais significativos
(mais a esquerda) formam um campo chamado opcode. Ele pode conter um
cdigo de uma instruo em particular, ou um cdigo que indica uma famlia
de instrues. No nosso exemplo da instruo add, o opcode vale 0000002
indicando uma famlia de instrues. Os 6 bits menos significativos so
responsveis ento por definir que instruo est codificada. Este campo ns
chamamos de funo (function). Os operandos so indicados em uma ordem
particular. O campo rd significa registrador de destino, o campo rs,
registrador de fonte (source) e o campo rt, registrador de alvo (target), que
pode ser destino ou fonte.
A Figura 3.1 mostra os campos da instruo add $8, $9, $10.
Como o opcode vale 0000002, a instruo definida pelo campo function. Este
campo vale 32 (1000002) para instruo add. O campo rs indica o
registrador que compe a primeira parcela da soma. O campo rt, a segunda.
O campo rd indica o registrador onde o resultado da soma ser colocado.
67
68
add $8, $9, $10
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 0 0
0 1 0 0 1 0 1 0 1 0 0 1 0 0 0
opcode
rs
rt
X X X X X 1 0 0 0 0 0
rd
function
Figura 3.1: Instruo add $8, $9, $10 em linguagem de mquina
Os campos rs, rd e rt guardam os nmeros dos registradores

operandos da instruo. Existe um campo no utilizado entre os bits 6 e 10,
inclusive. Veremos que este campo ser utilizado para outra funcionalidade,
mas por enquanto vamos consider-lo como sendo sempre 000002.
Agora vamos a um exemplo inverso: dado o cdigo de mquina,
desejamos encontrar o cdigo assembly correspondente. A instruo dada
como sendo 016c820h. A primeira coisa a fazer encontrar a representao
binria correspondente. Em seguida vamos procurar os 6 bits mais
significativos e descobrimos que eles valem 0000002. Ora, j sabemos que este
valor no campo opcode indica uma famlia de instrues e a instruo dentro
desta famlia indicada pelos 6 bits menos significativos. Ento olhamos para
os 6 bits menos significativos, eles indicam 1000002. Este valor no campo
function indica uma instruo de soma. Bem, ento agora s mostrar quais
so os campos da instruo e distribuir os bits neles. Da, encontraremos rs
valendo 010112, rt valendo 011002 e rd valendo 011012. Agora
reconstrumos a instruo add rs, rt, rd = add $11, $12, $13. A
Figura 3.2 mostra o processo de descoberta da instruo correspondente.
0000
0001
0110
1100
0110
1000
0010
0000
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 0 0
opcode
0 1 1 0 0 0 1 1 0 1 0 1 0 1 1
rs
rt
0 0 0 0 0 1 0 0 0 0 0
rd
function
add $11, $12, $13

Figura 3.2: Instruo add $11, $12, $13 em linguagem de mquina
69
Captulo 3: Linguagem de Mquina
Agora vamos outra instruo: sub $8, $10, $11. Esta instruo
tambm tem um opcode igual a 0000002. Isto indica que ela pertence mesma
famlia da instruo add. O valor do campo function : 1000102. A
codificao segue o mesmo padro: 6 bits para opcode, 5 para rs, 5 para
rt, 5 para rd, 5 desconsiderados e 6 para function, nesta seqncia
necessariamente. A Figura 3.3 mostra a codificao da instruo.
sub $8, $10, $11
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 0 0
opcode
0 1 0 1 0 0 1 0 1 1 0 1 0 0 0
rs
rt
X X X X X 1 0 0 0 1 0
rd
function
Figura 3.3: Instruo sub $8, $10, $11 em linguagem de mquina
Para finalizarmos esta famlia vamos ver a codificao da instruo

sll $8, $9, 3. Esta tambm uma instruo que segue o mesmo padro
de codificao. Observe, entretanto que existe uma quantidade especificada na
instruo, que o montante de bits do dado no registrador rt que iremos
deslocar para esquerda. rd dever conter o resultado da operao e rs
desprezado (colocado em 000002). Bem, ento fica faltando como especificar
a quantidade 3 que representa o montante do deslocamento. Este montante
representado em um campo chamado montante de deslocamento, sa (shift
amount). So usados os bits de 6 a 10 para ser o sa. A Figura 3.4 mostra a
codificao da instruo sll $8, $9, 3, onde function vale 0000002.
sll $8, $9, 3
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 0 0
opcode
0 0 0 0 0 0 1 0 0 1 0 1 0 0 0
rs
rt
rd
0 0 0 1 1 0 0 0 0 0 0
sa
function
Figura 3.3: Instruo sll $8, $9, 3 em linguagem de mquina
70
Este formato de codificao de instrues compartilhado por muitas

instrues e ele recebe um nome: formato R. A Tabela 3.1 mostra a
codificao das principais instrues do tipo R. Observe que a instruo mul,
embora compartilhe este formato, no tem como opcode o valor 0000002.
Nome
Formato
Exemplo
sll
srl
jr
mfhi
mflo
mult
multu
div
divu
add
addu
sub
subu
and
or
slt
sltu
mul
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
sll $8, $9, 3

srl $8, $9, 3
jr $8
mfhi $8
mflo $8
mult $9, $10
multu $9, $10
div $9, $10
divu $9, $10
add $8, $9, $10
addu $8, $9, $10
sub $8, $9, $10
subu $8, $9, $10
and $8, $9, $10
or $8, $9, $10
slt $8, $9, $10
sltu $8, $9, $10
mul $8, $9, $10
Codificao
opcode
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
28
rs
9
0
8
0
0
9
9
9
9
9
9
9
9
9
9
9
9
9
rt
10
10
0
0
0
10
10
10
10
10
10
10
10
10
10
10
10
10
rd
8
8
0
8
8
0
0
0
0
8
8
8
8
8
8
8
8
8
sa
3
3
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
function
0
2
8
16
18
24
25
26
27
32
33
34
35
36
37
42
43
2
Tabela 3.1: Instrues da famlia R
Bem, agora j conhecemos a codificao de diversas instrues no

MIPS. Vamos conhecer um outro formato possvel. So as instrues do tipo
I, onde um dado imediato vem na codificao da prpria instruo.
Comecemos com a instruo addi $8, $9, 3. Esta instruo
especifica uma parcela da soma em um operando e a outra na prpria
instruo. A Figura 3.4 mostra a codificao utilizada. Um campo
addi $8, $9, 3
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 1 0 0 0
opcode
0 1 0 0 1 0 1 0 0 0
rs
rt
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
immediate
Figura 3.4: Instruo addi $8, $9, 3 em linguagem de mquina
71
immediate usado para indicar a quantidade que ser somada ao

registrador rs. O destino o registrador rt. O campo opcode indica agora a
instruo especificamente, e no uma famlia.
Observe que o campo immediate contm 16 bits, o que implica na
limitao de um dos operandos faixa entre 32768 e +32767. Isto algo
importante
na
nossa
programao,
pois
uma
instruo
addi $8, $9, 128256, embora parea vlida, no possvel ser
codificada.
Outra instruo do tipo I a lw. lw usa o campo immediate, como
sendo um deslocamento a partir de um endereo base especificado em um
registrador, como vimos no Captulo anterior. A Figura 3.5 mostra a
codificao de lw, que tambm seguida por sw.
lw $8, 8($9)
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
1 0 0 0 1 1
opcode
0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
rs
rt
immediate
Figura 3.5: Instruo lw $8, 8($9) em linguagem de mquina
Finalmente, dentro deste formato existem as instrues beq e bne.

Vamos precisar entender agora como formado um endereo alvo de uma
instruo condicional de salto. Assim como na instruo de carga de
registradores existe um endereo base e um deslocamento, na instruo de
desvio tambm existe um deslocamento. O registrador que guarda o endereo
base, entretanto, est implcito, o que significa dizer que ele no ser
declarado na instruo. Bem, este tal registrador justamente o PC. Ento o
deslocamento, estipulado no campo immediate da instruo de desvio
condicional somado ao valor de PC para informar ao processador qual o
endereo da prxima instruo a ser executada.
A
Figura
3.6
mostra
a
codificao
da
instruo
beq $8, $9, endereo_alvo. Veja que neste caso um deslocamento,
a partir do valor de PC, aplicado, o que nos leva a refletir que a instruo
beq um desvio condicional relativo a PC. Este modo de endereamento,
chamado relativo a PC, pois o prximo valor a ser endereado depende do
valor atual do PC.
72
beq $8, $9, endereco_alvo
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 1 0 0
opcode
0 1 0 0 0 0 1 0 0 1 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
rs
rt
immediate
Novo valor de PC
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
PC
0 0 0 0 0 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Figura 3.6: Instruo beq $8, $9, alvo em linguagem de mquina
Um aspecto muito importante nesta construo de desvios (instrues

de saltos, como beq e bne) que todas as instrues tm 32 bits, o que
implica que a instruo antecessora da atual difere, em seu endereo
de 4bytes. Seria um desperdcio ento utilizar este campo immediate para
enderear bytes, j que nunca os bits 0 e 1 seriam diferentes de 0. Por este
motivo, o valor imediato especificado na instruo, antes de ser somado ao
valor de PC deslocado duas casas para esquerda, ou seja, o campo
immediate, no final das contas, indica para quantas instrues antes ou
depois da atual deve ser o salto, caso ocorra.
Vamos recorrer a uma adaptao do exemplo da Figura 2.11, mostrada
novamente na Figura 3.7. A codificao do opcode e dos registradores
formam os primeiros 16 bits da instruo: 1109h. O valor do deslocamento
especificado como a distncia entre a instruo atual e o seu alvo. Como o
alvo da instruo de salto est duas instrues abaixo, precisamos especificar
o campo immediate como sendo +2, isto , 0002h. Assim a codificao
final da instruo : 11090002h, como visto na figura.
Quando estudarmos pipeline veremos que esta codificao uma
aproximao da realidade, mas vamos deixar esta discusso para o futuro. Por
enquanto vamos assumir exatamente este modelo.
73
Processador
...
$8 00000004
$9 00000004
$10 00000000
...
PC
00400000
Memria
dados /
endereos
instrues
instrues
00000000h
...
...
00400000h 11090002
00400004h 01095020
00400008h 00000000
...
...
beq $8, $9, sai

add $10, $8, $9
sai: nop
...
00000000h
...
...
00400000h 11090002
00400004h 01095020
00400008h 00000000
...
...
beq $8, $9, sai

add $10, $8, $9
sai: nop
...
...
$8 00000004
$9 00000004
$10 00000000
...
PC
00400008
Figura 3.7: Execuo e codificao, em linguagem de mquina, da

instruo beq $8, $9, sai
Vamos fazer um exemplo inverso, dado a codificao em hexadecimal

de uma instruo de salto vamos encontrar como seria sua equivalente em
linguagem de montagem. A instruo : 1509fffdh. Primeiro comeamos
encontrando a codificao equivalente em binrio. O opcode 0001012. Se
observarmos o exemplo original na Figura 2.11, vamos perceber que se trata
do opcode da instruo bne. Ora, bne possui o mesmo formato de
codificao de beq, ento podemos separar os campos rs e rt para encontrar
os registradores que sero comparados, neste caso $8 e $9 e vamos encontrar o
alvo. Os 16 bits menos significativos indicam: fffdh. Portanto, este um
nmero negativo, considerando que sua codificao est em 16bits. O seu
equivalente em decimal vale 3. Agora chegamos concluso que se trata da
instruo bne $8, $9, 3. Este 3 a representao numrica de um
rtulo do cdigo. Um possvel trecho de cdigo que usa esta instruo
mostrado a seguir e a desmontagem est na Figura 3.8.
...
rotulo: lw ....
lw ...
addi ...
bne $8, $9, rotulo #alvo -3 instrues
74
0001
0101
0000
1001
1111
1111
1111
1101
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 1 0 1
opcode
0 1 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1
rs
rt
immediate
bne $8, $9, -3

Figura 3.8: Desmontagem da instruo bne $8, $9, -3 em
linguagem de mquina
Uma observao final neste modelo que podemos saltar para

instrues que esto distantes at +32767 ou 32768 palavras da atual.
Vamos sumarizar as instrues do tipo I. A Tabela 3.2 mostra as
principais instrues do MIPS que seguem este formato. Cuidado com a
especificao dos registradores de beq e bne, pois eles so colocados em
ordem direta na codificao e tambm, em lui, no existe o registrador rs.
Nome
Formato
Exemplo
beq
bne
addi
addiu
slti
sltiu
andi
ori
lui
lw
sw
I
I
I
I
I
I
I
I
I
I
I
beq $8, $9, 3

bne $8, $9, 3
addi $8, $9, 3
addiu $8, $9, 3
slti $8, $9, 3
sltiu $8, $9, 3
andi $8, $9, 3
ori $8, $9, 3
lui $8, 3
lw $8, 4($9)
sw $8, 4($9)
Codificao
opcode
4
5
8
9
10
11
12
13
15
35
43
rs
8
8
9
9
9
9
9
9
0
9
9
rt
9
9
8
8
8
8
8
8
8
8
8
Tabela 3.2: Instrues da famlia I
immediate
3
3
3
3
3
3
3
3
3
4
4
75
Finalmente chegamos ao ltimo formato de instrues admitido pelo

MIPS. Trata-se do formato J. Este formato usado por instrues de desvio
incondicional, como j, e jal. Ele composto basicamente de um opcode e
todos os demais bits so utilizados para endereamento. A Figura 3.9 mostra o
exemplo para instruo j endereo.
j endereo
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
opcode
address
Figura 3.9: Instruo j endereo em linguagem de mquina
Assim como as instrues bne e beq usam um campo de 16 bits que

transformado em 18 bits para ser somado ao PC, os 26 bits do campo
address deste formato tambm so deslocados esquerda para serem
transformados em 28 bits. Mas as similaridades param por a. O clculo do
endereo de alvo do salto incondicional feito de forma completamente
diferente. A idia que haja uma independncia do valor de PC. Este modo de
endereamento chamado de endereamento direto.
Infelizmente apenas 28 bits de endereo (26 explcitos e 2 implcitos)
so carregados na instruo, o que no permite completar os 32 bits exigidos
pela arquitetura. Assim, tomamos emprestado os 4 bits mais significativos do
valor de PC para completar o endereo do alvo da instruo de salto.
Formamos assim um modo de endereamento chamado de endereamento
pseudo-direto pois ele tende a ser independente do PC, mas precisa utilizar
alguns bits dele.
A Figura 3.10 mostra como feito o clculo do endereo alvo de uma
instruo j. O campo address da instruo escrito em PC,
independentemente do que ali existia anteriormente. Entretanto, apenas os bits
de nmero 2 a 27 so alterados. O nibble mais significativo do valor de PC
fica mantido intacto. Veja que os nossos programas ocupam, no modelo de
memria estabelecido, entre os endereos 00400000h at 0ffffffch. Isto nos
permite uma certa tranqilidade, pois sabemos que o primeiro nibble do
endereo contido em PC sempre ser 0h.
76
j endereo
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
opcode
address
Novo valor de PC
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
PC
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
PC
0 0 0 0 0 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Antigo valor de PC
Figura 3.10: Instruo e clculo de endereo para instruo
j endereo em linguagem de mquina
Como deduzimos da Figura 3.9, o opcode associado instruo j

0000102. Agora vamos ver um exemplo de como feito o clculo do campo
address desta instruo. Vamos utilizar o exemplo da Figura 2.15
reproduzida a seguir, como Figura 3.11, para facilitar a leitura. Vamos prestar
ateno na codificao da instruo j sai. Ela exatamente a mesma
mostrada na Figura 3.9. O Campo address contm o valor 0100004h.
Quando o processador vai executar esta instruo ele multiplica este valor por
quatro (desloca dois bits esquerda). Isto nos leva a 0400010h. Este valor ir
sobrepor os 28 bits mais baixos do PC. O primeiro nibble do PC fica como
estava: 0h. O endereo de destino passa ento a ser 00400010h. Justamente
onde o rtulo sai est.
O campo de 26 bits no operado (somado, subtrado, etc) a nenhum
outro valor, portanto, no faz sentido em falarmos de valores sinalizados ou
no.
77
Processador
Memria
dados /
endereos
instrues
...
$8 00000004
$9 00000004
$10 00000000
...
PC
00400000
$8 00000004
$9 00000004
$10 00000008
...
PC
00400004
$8 00000004
$9 00000004
$10 00000008
...
PC
00400008
$8 00000004
$9 00000004
$10 00000008
...
PC
00400010
instrues
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
...
00400000h
00400004h
00400008h
0040000ch
00400010h
...
...
15090003
01095020
08100004
01095022
00000000
...
bne $8, $9, else

add $10, $8, $9
j sai
else: sub $10, $8, $9
sai: nop
...
Figura 3.11: Execuo de uma estrutura if-then-else no MIPS
A instruo jal opera exatamente da mesma forma. Apenas a

funcionalidade de escrever o valor de PC+4 em $ra acrescentada. A
codificao segue a mesma lgica, mas o valor do opcode passa a ser 3. A
Tabela 3.3 mostra a codificao das instrues do tipo J.
Nome
Formato
Exemplo
j
jal
J
J
j 1000
jal 1000
Codificao
opcode
2
3
Tabela 3.3: Instrues da famlia J
endereo
1000
1000
78
Agora vamos apresentar o quadro completo com os formatos utilizados

pelas principais instrues do MIPS. Este quadro muito didtico, mas tende
a ficar muito grande se o nmero de instrues tambm o for. Por isto
apresentaremos tambm a forma mais convencional encontrada nos manuais
das ISAs dos processadores.
Nome
Formato
Exemplo
sll
srl
jr
mfhi
mflo
mult
multu
div
divu
add
addu
sub
subu
and
or
slt
sltu
mul
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
R
sll $8, $9, 3

srl $8, $9, 3
jr $8
mfhi $8
mflo $8
mult $9, $10
multu $9, $10
div $9, $10
divu $9, $10
add $8, $9, $10
addu $8, $9, $10
sub $8, $9, $10
subu $8, $9, $10
and $8, $9, $10
or $8, $9, $10
slt $8, $9, $10
sltu $8, $9, $10
mul $8, $9, $10
beq
bne
addi
addiu
slti
sltiu
andi
ori
lui
lw
sw
I
I
I
I
I
I
I
I
I
I
I
beq $8, $9, 3

bne $8, $9, 3
addi $8, $9, 3
addiu $8, $9, 3
slti $8, $9, 3
sltiu $8, $9, 3
andi $8, $9, 3
ori $8, $9, 3
lui $8, 3
lw $8, 4($9)
sw $8, 4($9)
j
jal
J
J
j 1000
jal 1000
Codificao
opcode
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
28
opcode
4
5
8
9
10
11
12
13
15
35
43
opcode
2
3
rs
9
0
8
0
0
9
9
9
9
9
9
9
9
9
9
9
9
9
rs
8
8
9
9
9
9
9
9
0
9
9
rt
10
10
0
0
0
10
10
10
10
10
10
10
10
10
10
10
10
10
rt
9
9
8
8
8
8
8
8
8
8
8
rd
8
8
0
8
8
0
0
0
0
8
8
8
8
8
8
8
8
8
sa
function
3
0
3
2
0
8
0
16
0
18
0
24
0
25
0
26
0
27
0
32
0
33
0
34
0
35
0
36
0
37
0
42
0
43
0
2
immediate
3
3
3
3
3
3
3
3
3
4
4
address
1000
1000
Tabela 3.4: Sumrio da codificao das principais instrues do MIPS
79
A forma apresentada a seguir usa uma abordagem parecida com o que

acontece de fato em um processador para que o mesmo possa decodificar a
instruo. A decodificao significa encontrar a instruo que dever ser
executada para que todas os sinais eltricos sejam enviados via de dados
corretamente. A decodificao no MIPS ocorre em primeiro plano na
observao dos 6 bits que formam o opcode. A Figura 3.12 mostra a
decodificao inicial. Veja que em alguns as clulas da tabela esto grafadas
em maisculo. Neste caso, no se trata de uma instruo especfica, mas de
uma ligao para outra tabela. Ns vamos mostrar apenas a tabela chamada
SPECIAL, por isto ela est sublinhada. As instrues que ns estudamos esto
destacadas em negrito. As demais instrues e tabelas ficam por conta da
curiosidade do leitor.
Veja que neste tipo de tabela no existe informao sobre a codificao
do restante dos campos. preciso o auxlio de uma figura com os formatos e a
listagem das instrues para cada formato. Os formatos esto na Figura 3.13.
opcode
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
bits [31..29]
bits [28..26]
000
001
010
011
100
101
110
111
000
001
SPECIAL
REGIMM
addi
addiu
010
j
slti
011
jal
sltiu
COP0
COP1
COP2
COPIX
lb
sb
ll
sc
lh
sh
lwc1
swc1
lwl
swl
lwc2
swc2
lw
sw
pref
100
beq
andi
101
bne
ori
SPECIAL2
jalx
lhu
lbu
110
blez
xori
111
bgtz
lui
SPECIAL3
lwr
swr
ldc2
sdc2
ldc1
sdc1
cache
Figura 3.12: Tabela de codificao das instrues

31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
opcode
address
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
opcode
rs
rt
immediate
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
opcode
rs
rt
rd
as
Figura 3.13: Codificao dos formatos
function
80
function
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
bits [5..3]
0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
bits [2..0]
000
001
010
011
100
101
110
111
000
sll
jr
mfhi
mult
add
001
MOVCI
jalr
mthi
multu
addu
tge
tgeu
010
srl
movz
mflo
div
sub
slt
tlt
011
sra
movn
mtlo
divu
subu
sltu
tltu
100
sllv
syscall
break
and
or
teq
101
110
srlv
111
srav
sync
xor
nor
tne
Figura 3.14: Tabela de codificao das instrues
Uma vez feita a primeira decodificao preciso saber se ainda

necessrio a busca por mais uma tabela. o caso das clulas que esto
marcadas na tabela original como SPECIAL, entre outras. A Figura 3.14
mostra as instrues presentes nesta tabela. No exemplo da figura iramos
chegar a concluso que se trata da instruo sra, cujo formato R. Os
restantes dos bits seriam decodificados nos campos rs, rt, rd e as.
Agora j chegamos a uma fase em que sabemos decodificar e montar
qualquer instruo do MIPS (contida no texto). Vamos ento abordar outros
temas relevantes para este captulo.
3.2 Uso da linguagem de mquina

Nas sees seguintes iremos conhecer dois tpicos importantes na
formao das linguagens de mquina. Como j mencionamos a complexidade
dos sistemas eletrnicos nos levou a construir abstraes. Estas abstraes
tampouco so manipuladas sem auxlio de ferramentas. Por isto, hoje ao
projetarmos um processador vamos usar, em um primeiro estgio, uma
linguagem de descrio de hardware, HDL (Hardware Description
Language). Esta linguagem um software capaz de descrever o
comportamento de um hardware e de seus componentes. As mais famosas
linguagens de descrio de hardware so VERILOG e VHDL. SystemC
recm-chegada ao grupo, mas est tendo um impacto muito importante na
comunidade cientfica hoje.
81
Uma linguagem de descrio de hardware pode ser utilizada com dois

propsitos: simular o comportamento da arquitetura e gerar um prottipo da
mesma. Depois de simulada, a arquitetura passa por refinamentos constantes
at atingir o ponto de satisfao desejado. Uma vez estvel a descrio do
hardware, um processo de sntese iniciado. A sntese a converso do
modelo descrito em uma HDL para um prottipo fsico. Este processo tambm
feito com uma ferramenta, parecida com um compilador.
O processo de refinamento permite que partes do cdigo sejam
melhoradas e/ou detalhadas para que se tenha uma nova simulao e a
corretude do modelo seja validada.
O processo de refinamento existe para prover uma melhor especificao
do cdigo, um melhor particionamento do projeto e a verificao de erros.
Tudo isto, embora seja necessrio, acaba consumindo muito tempo no projeto
do sistema. Isto implica que o produto demora a chegar ao mercado. A Figura
3.15 Indica o processo bsico de simulao e sntese de um projeto desenhado
com uma HDL (SystemC).
SystemC
Simulao
Refinamento
Sntese
Figura 3.15: projeto de um sistema utilizando HDLs
82
A viso do software
Um produto para chegar ao mercado e fazer sucesso precisa ter

associado a ele um conjunto de ferramentas bsicas que permitam ao
desenvolvedor de software utilizar os recursos da nova arquitetura. Este toolkit
deve ser composto, no mnimo, de compiladores, montadores, ligadores e
simuladores eficientes. Estas ferramentas, entretanto, so difceis de serem
geradas automaticamente a partir da descrio de um sistema em uma HDL
porque as possibilidades de modelos de programao so muito variadas.
Assim, estamos vendo hoje uma tendncia no desenvolvimento de um projeto
onde no mais utilizamos uma HDL, mas passamos a utilizar uma Linguagem
de Descrio de Arquitetura, ADL (Architecture Description Language).
Um exemplo de ADL conhecida LISA. Ns vamos estudar uma nova
ADL, surgida recentemente, chamada ArchC, que gera cdigo para SystemC.
Baseados em ArchC, podemos criar automaticamente um montador e usar a
mesma funcionalidade do SystemC para simulao da arquitetura. A gerao
automtica do compilador para ArchC ainda est em desenvolvimento, mas
existem tcnicas de re-target do GCC no site da ferramenta.
Alm de apresentar o ArchC na seo seguinte, vamos tambm explorar
a anatomia de uma cdigo executvel. Quando compilamos um cdigo, no
somente informaes de dados e instrues esto presentes no objeto gerado,
mas tambm, e principalmente uma tabela de smbolos que permitem ao
Sistema Operacional relocar o cdigo para outras posies de memria.
Vamos conhecer um pouco da especificao de um cdigo executvel no
formato ELF (Executable and Linking Format), que executado normalmente
na maioria das distribuies linux.
Ambas as sees fazem parte da viso do software, que de
importncia para o conhecimento de um aluno de um curso fortemente
baseado em software.
3.3 A viso do software ArchC

O ArchC uma ADL capaz de descrever o comportamento de uma
arquitetura em diversos nveis de abstrao. O modelo mais simples de
descrio o modelo funcional, onde apenas as instrues so declaradas e
suas funcionalidades sobre os recursos bsicos da mquina, sem considerar,
contudo, as inmeras implicaes que a temporizao do modelo pode
exercer sobre ele.
A construo de um modelo funcional traz para o projetista a idia de
que as operaes das quais ele precisa esto corretas e realizam as tarefas
exatamente como proposto. Uma descrio neste nvel de abstrao requer
muito pouco conhecimento da organizao do computador e um modelo
83
simples de execuo das instrues. A medida que refinamentos so feitos at

chegarmos a um modelo mais complexo, acurado a ciclos, os recursos vo
sendo redefinidos.
Neste captulo iremos apresentar uma descrio funcional da ISA do
MIPS no formato do ArchC.
O ArchC utiliza basicamente dois arquivos de entrada: o primeiro
contendo a descrio da arquitetura e o segundo a descrio da ISA. A
Figura 3.16 mostra o fluxo de projeto utilizando ArchC e a camada SystemC
abaixo, at gerar uma especificao executvel.
AC_ISA
AC_ARCHC
Gerador de
Simuladores do
ArchC
GCC
SystemC
Especificao
Executvel
Figura 3.16: fluxo de projeto com ArchC
A viso do software
Modelo
SystemC
84
84
Dentro do arquivo de descrio do ISA (AC_ISA) o projetista

especifica detalhes dos formatos das instrues, tamanhos e nomes e todas as
informaes necessrias para decodificao e para simulao do
comportamento de cada instruo. O arquivo de Recursos de Hardware
(AC_ARCH) contm informaes acerca da memria, estrutura do pipeline
etc.
A descrio de recursos que vamos utilizar a mais simples possvel,
tipicamente para implementao de um modelo funcional. O arquivo
mips1.ac contm as linhas de cdigo mostradas na Figura 3.17. O
tamanho da palavra 32 bits. Existe uma memria principal de 256kbytes e
um banco de registradores com 34 registradores. O construtor do MIPS
utiliza o arquivo mips_isa.ac para prover as informaes sobre as
instrues e o endian setado para big.
AC_ARCH(mips){
ac_wordsize 32;
ac_mem MEM:256k;
ac_regbank RB:34;
ARCH_CTOR(mips){
ac_isa(mips_isa.ac);
set_endian(big);
};
};
A viso do software
Figura 3.17: Descrio do modelo funcional do MIPS em ArchC
A descrio do modelo funcional do ISA pode ser visto na Figura 3.18.

Inicialmente so especificados os tipos e seus campos. Nesta especificao,
%op:6 indica que existe um campo chamado op e cujo tamanho de 6 bits.
Os demais campos seguem o mesmo padro.
Em seguida so especificadas as instrues que utilizam cada um dos
formatos descritos acima. ac_instr<Type_J> j, jal; indica que as
instrues j e jal possuem sua codificao binria seguindo o formato
Type_J.
Depois desta especificao necessrio indicar se existem apelidos
para os registradores, o que feito na seo ac_asm_reg.
Finalmente, o construtor do ISA especifica as instrues e a forma de
decodific-las. Por exemplo,
lw.set_asm(lw %reg, %imm(%reg), rt, imm, rs);
indica que a instruo lw formada por um registrador, um imediato e outro
registrador. Os campos utilizados para estes trs parmetros so: rt, imm
e rs. Em seguida vem a decodificao que feita exclusivamente pelo campo
85
op, cujo valor deve ser 23h (0x23 outra forma de representar o valor em
hexadecimal).
AC_ISA(mips){
ac_format Type_R = %op:6 %rs:5 %rt:5 %rd:5 0x00:5 %func:6;
ac_format Type_I = %op:6 %rs:5 %rt:5 %imm:16:s;
ac_format Type_J = %op:6 %addr:26;
ac_instr<Type_R> add, addu, subu, multu, divu, sltu;
ac_instr<Type_I> lw, sw, beq, bne, addi, andi, ori, lui, sltu;
ac_instr<Type_J> j, jal;
ac_asm_reg{
"$"[0..31] = [0..31];
"$zero" = 0;
"$at" = 1;
"$kt"[0..1] = [26..27];
"$gp" = 28;
"$sp" = 29;
"$fp" = 30;
"$ra" = 31;
};
ISA_CTOR(mips){
lw.set_asm(lw %reg, %imm(%reg), rt, imm, rs);
lw.set_decoder(op=0x23);
add.set_asm(add %reg, %reg, %reg, rd, rs, rt);
add.set_decoder(op=0x00, func=0x20);
};
}
Uma vez descritos os dois arquivos, quando processados pelo gerador

de simulador do ArchC criado um arquivo de molde para a definio do
comportamento de cada instruo. tambm possvel especificar um
comportamento geral, para todas as instrues ou um comportamento
especfico para um tipo. Por exemplo, um trecho do molde do modelo do
MIPS preenchido pode ser visto na Figura 3.19. A instruo lw por exemplo
tem o seu comportamento descrito como,
RB[rt] = DM.read(RB[rs]+ imm);
Isto significa que o registrador apontado por rt no banco de registradores
ir receber o contedo da memria no endereo formado pela soma do valor
imm da instruo e do valor guardado no registrador apontado por rs do
banco de registradores.
A viso do software
Figura 3.18: Descrio do ISA do MIPS em ArchC
86
86

...
void ac_behavior( instruction ){
ac_pc = ac_pc +4;
};
void ac_behavior( Type_R ){};
void ac_behavior( lw )
{
RB[rt] = DM.read(RB[rs]+ imm);
};
void ac_behavior( slti )
{
// Set the RD if RS< IMM
if( (ac_Sword) RB[rs] < (ac_Sword) imm )
RB[rt] = 1;
// Else reset RD
else
RB[rt] = 0;
};
...
Figura 3.19: Comportamento do ISA do MIPS em ArchC
A viso do software
Veja tambm que existe um comportamento associado a todas as

instrues: a soma do valor de PC (ac_pc). Esta varivel pode ser reescrita
por uma descrio de um comportamento em particular, como o caso das
instrues de salto.
Trechos das especificaes do MIPS em ArchC foram apresentadas.
Resta o leitor explorar a ADL para concluir a especificao de, ao menos, as
instrues apresentadas at o presente momento.
3.4 A viso do software ELF

O formato de ligao e executvel foi desenvolvido originalmente pela
UNIX System Laboratories. O Formato ELF foi um padro projetado para
ser executado em arquiteturas Intel de 32 bits numa variedade de sistemas
operacionais. Hoje a plataforma que popularizou o ELF a combinao da
arquitetura Intel com o sistema operacional linux. Isto no significa que
outras mquinas, de outras famlias no possam executar um arquivo neste
formato.
Existem trs tipos de objetos que podem ser representados neste
formato:
- um arquivo relocvel, que contm dados e instrues para serem

ligados com outros arquivos objetos para criar um programa executvel ou
um arquivo objeto compartilhado;
- um arquivo executvel, que contm informaes suficientes para a
criao de um processo pelo sistema operacional; e
- um arquivo objeto compartilhado, que contm informaes
suficientes para ligao em duas formas: o ligador pode lig-lo com outro
objeto compartilhado ou relocvel; ou o ligador pode lig-lo com um arquivo
executvel.
Ns vamos nos ater ao formato de arquivo executvel. Um arquivo
executvel normalmente contm algumas sees (trechos) de cdigos e dados,
que podem ser agrupados em segmentos. Tanto as sees como os segmentos
esto, via de regra, dentro do prprio arquivo executvel. Existe tambm um
cabealho das sees, que de fato uma tabela contendo informaes sobre a
localizao, tipo e tamanho de cada seo; um cabealho de segmentos
(chamado cabealho de programas), que indica localizao, tipo e tamanho
do segmento; e um cabealho geral que indica onde est cada cabealho no
cdigo.
A Figura 3.20 mostra a viso geral do formato. Interessante perceber
que os segmentos possuem informaes necessrias para o processo de
carregamento do Sistema Operacional, portanto, um arquivo s ser
executvel se possuir o cabealho de programas. Por outro lado, para ser
ligvel, preciso utilizar informaes particulares das sees, ento um
arquivo para ser ligado a outro pelo ligador precisa ter um cabealho de
sees.
Os cabealhos geral, de sees e de programa possuem uma definio
extremamente rgida e precisam seguir o padro para que os contedos de
cada parte do objeto sejam corretamente interpretados.
O cabealho geral uma estrutura contendo 52 bytes que definem as
informaes contidas no arquivo ELF. Dentro deste cabealho esto
definidos os deslocamentos, em bytes, desde o incio do arquivo, do
cabealho de programas e do cabealho de sees.
87
A viso do software
88
88
Cabealho Geral ELF

Cabealho de Programa
Segmento 1
...
Segmento n
Seo 1
Seo 2
...
Seo n
Cabealho de Sees
A viso do software
Figura 3.20: viso geral dos contedos de um arquivo

executvel e ligvel no formato ELF
O cabealho de programas uma tabela contendo em cada entrada

informaes sobre o segmento associado. O cabealho de sees segue o
mesmo padro, ou seja, contm uma tabela onde cada entrada contm
informaes sobre a seo associada. A Figura 3.21 ilustra esta hierarquia.
Veja que no Cabealho Geral esto contidas as seguintes informaes sobre
o Cabealho de Programa: deslocamento desde o incio do arquivo onde
comea tal cabealho; tamanho de cada entrada no cabealho (todas as
entradas tm o mesmo tamanho); e nmero de entradas na tabela.
Por sua vez, cada entrada do Cabealho de Programas tem, entre
outras informaes, o deslocamento (em bytes) desde o incio do arquivo
onde se encontra o Segmento associado e o tamanho deste Segmento. Isto
ocorre tambm, de forma similar, com o Cabealho de Sees.
Vamos a seguir verificar o que existe de fato dentro de cada parte dos
cabealhos.
89
byte
0
Cabealho
Geral
...
deslocamento
cabe. programa (m)
deslocamento
cabe. Sees (n)
51
Nmero de entradas
na tabela Sees (T)
...
Desl. Segm. 1 (k)

Tamanho Segm. 1
...
Desl. Segm. z (x)

Tamanho Segm. z
...
Nmero de entradas
na tabela Program (z)
Tamanho entrada
tabela Sees
Cabealho
Programas
...
Tamanho entrada
tabela Programa
Cabealho
Sees
n
Segmento 1
Desl. Seo 1 (i)

Tamanho Seo 1
...
Desl. Seo 2 (j)
Tamanho Seo 2
...
...
Segmento z
Seo 1
Seo 2
...
Desl. Seo T (l)
Tamanho Seo T
...
...
Seo T
Figura 3.21: Cabealhos, Segmentos e Sees no formato ELF
O cabealho geral contm no primeiro byte um nmero especfico: 7fh.

Isto obrigatrio para identificao do tipo do arquivo, bem como a
seqncia de bytes 45h, 4ch, 46h (que so os valores associados s letras E, L
e F). Em seguida um byte especifica a classe do arquivo: 0, classe
invlida; 1, objeto de 32 bits; e 2 objeto de 64 bits. Atualmente a maioria das
mquinas utilizam a classe 1. O prximo campo indica a forma como um
nmero de 32 bits est organizado nos bytes. No caso de little endian o
endereo de menor valor recebe o byte menos significativo, ou seja, mais
direita. No caso de big endian, o endereo menor recebe o byte mais
A viso do software
90
90
significativo. Mquinas Intel normalmente utilizam little endian e mquinas

RISC como SPARC normalmente usam big endian. H tambm mquinas que
admitem os dois, como a MIPS. Finalmente chegamos verso do
cabealho usado. Hoje s utilizamos o valor 1. Os demais bits at o valor 15
podem ser usado para futuras especificaes do ELF. No presente eles so
postos todos em 0.
Podemos j observar estes campos na Figura 3.22. O nmero
apresentado sobre cada campo representa o byte do arquivo. No h campos
menores que um byte na especificao do ELF.
7fh
32
33
49
mquina
34
50
35
verso
36
37
38
sinalizadores
(flags)
10 11 12
13 14 15
padding = 0
19 20 21 22 23
deslocamento
cabealho sees
48
F clas- end- cab.

se dian ver.
16 17 18
tipo
24 25 26 27 28 29 30 31
ponto de entrada
deslocamento
cabe. de programa
39 40 41 42 43 44 45 46 47
tamanho tamanho nmero de tamanho
cabe. ger entrada P entradas P entrada S
51
A viso do software
nmero
ndice
entrada S s. strings
Figura 3.22: Cabealho Geral no formato ELF
O campo tipo indica o tipo de objeto no formato ELF: 0, sem tipo; 1,

arquivo de relocao; 2, arquivo executvel; e 3, arquivo objeto
compartilhado. Os nossos executveis vo possuir ento este campo
assinalado como 1.
O campo mquina indica para qual mquina foi criado aquele
objeto: 0, nenhuma; 1, AT&T WE 32100; 2, SPARC; 3, Intel 80386; 4,
Motorola 68000; 5, Motorola 88000; 7, Intel 80860; e 8, MIPS RS3000.
Outras mquinas podem ter valores associados no futuro.
O campo verso, indica a verso do objeto. A este campo atribudo

o valor 1 correntemente.
O campo ponto de entrada indica o endereo onde ser iniciada
a execuo do programa. Um possvel valor seria 00400000h para o MIPS.
Os prximos dois campos indicam em qual byte do arquivo comeam
as tabelas (cabealho) de programas e de sees respectivamente.
Os sinalizadores referem-se a bits de sinalizao para mquina que ir
executar o cdigo. Este valor normalmente deixado em 0.
Os bytes 40 e 41 informam o tamanho, em bytes, do cabealho geral e
contm sempre o valor 34h (52).
Os bytes 42 e 43 indicam o tamanho de cada entrada no cabealho de
Programas, seguidos pelos bytes 44 e 45 que indicam quantas so estas
entradas.
Os bytes 46 a 49 so os anlogos tabela de programas, mas agora
associados com o cabealho de sees.
Finalmente est indicado nos ltimos bytes deste cabealho geral o
nmero da seo que contm informaes sobre os smbolos utilizados no
programa, como por exemplo, o rtulo dos alvos de instrues de desvio e os
nomes dos procedimentos. Esta seo especial contm cadeias de caracteres
(strings) terminadas com o byte 0.
Vamos agora analisar os dados presentes no cabealho de programas.
A Figura 3.23 indica os campos presentes em cada entrada do cabealho. O
campo tipo indica que tipo de segmento est associado a esta entrada. O
tipo mais comum o 1, que indica um segmento que ser carregado na
memria para execuo. O tamanho do segmento especificado no campo
tamanho segmento e a quantidade de memria necessria especificada
no campo tamanho memria. Em alguns casos o tamanho da memria
requerida maior que o tamanho do segmento, mas nunca ao contrrio.
+0
+1 +2 +3
tipo
+4
+5
+6 +7 +8 +9 +10 +11 +12 +13 +14 +15
deslocamento
endereo virtual
endereo fsico
+16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31
tamanho segmento
tamanho memria
sinalizadores
alinhamento
Figura 3.23: Cabealho de programas no formato ELF
A viso do software
91
A viso do software
92
92
O campo endereo virtual diz o endereo virtual que deve ser

utilizado para receber a primeira palavra do segmento (veremos o que
endereo virtual no captulo 6).
O campo endereo fsico diz o endereo fsico que deve ser
utilizado para receber a primeira palavra do segmento (veremos o que
endereo fsico no captulo 6).
O campo deslocamento indica o byte do arquivo onde se encontra
o primeiro byte do segmento. Os demais campos ficam por conta da
curiosidade do leitor em saber mais.
Esta estrutura de dados se repete tantas vezes quantas forem as
entradas do cabealho de programa.
Informaes semelhantes so encontradas em cada entrada do
cabealho de sees. Vamos analisar os principais campos de uma entrada
como apontados na Figura 3.24.
O campo nome indica um deslocamento dentro da seo especial de
cadeias de caracteres onde est o nome da seo.
O campo tipo indica o tipo de seo. Existem muitas definies de tipos
possveis. Os principais esto mostrados na Tabela 3.5. Certamente a de
maior impacto a de bits de programa, que contm as informaes das
instrues e dos dados do programa.
Os sinalizadores de cada seo so muito importantes. Existem 3
sinalizados especficos: WRITE, valor 1, ALLOC, valor 2 e EXECINSTR,
valor 4. WRITE significa que a seo contm dados que podem ser escritos
(alm de lidos). ALLOC significa que a seo ir ocupar espao na memria
e EXECINSTR significa que a seo contm instrues em linguagem de
mquina. Os sinalizadores podem ser usados em combinaes. Por exemplo,
o valor 6 (2+4) indica que a seo EXECINSTR e ALLOC ao mesmo
tempo.
O campo endereo indica o endereo na memria onde esta seo
deve aparecer, caso ela aloque espao na memria.
O campo deslocamento indica o primeiro byte onde est, no
arquivo, a seo associada.
O campo tamanho indica o tamanho da seo, em bytes. Os demais
campos ficam como exerccios.
93
+0
+1 +2 +3
+4
nome
+5
+6
+7 +8 +9 +10 +11 +12 +13 +14 +15
tipo
sinalizadores
endereo
+16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31
deslocamento
tamanho
link
informaes extras
+32 +33 +34 +35 +36 +37 +38 +39

alinhamento
tamanho entrada
Figura 3.24: Cabealho de sees no formato ELF
Tipo
NULL
PROGBITS
SYMTAB
STRTAB
RELA
HASH
DYNAMIC
NOTE
NOBITS
REL
SHLIB
Valor
0
1
2
3
4
5
6
7
8
9
10
Descrio
Seo inexistente
Bits do programa
Tabela de Smbolos
Tabela de Strings
Informaes de Relocao
Tabela de Espalhamento de Smbolos
Ligao dinmica
Anotaes sobre o arquivo
No ocupa espao no arquivo
Informaes de Relocao
Sem semntica especfica
Conhecer esta anatomia de um arquivo executvel importante para

aqueles que querem aprender um pouco mais sobre programao. Aqui
apresentamos um nico formato, mas existem outros especificados, por
exemplo, para o Sistema Operacional DOS e Windows. Ainda, existe outra
anatomia para Java Bytecodes. Conhecer uma delas importante para que
as demais possam ser mais facilmente entendidas.
A viso do software
Tabela 3.5: Tipos de Sees do ELF
94
3.5 Concluses
Conhecemos neste captulo como a codificao binria de uma poro
das instrues do MIPS. No tratamos, entretanto de todas as instrues, como
instrues de ponto flutuante ou de coprocessador. O que importa neste
instante que o leitor possa fazer uma traduo de cdigo de mquina para
cdigo de montagem e vice-versa.
Vimos tambm que o nmero de formatos disponveis no MIPS de
trs. Isto pode parecer um nmero muito pequeno, mas existe um benefcio
muito importante associado. A decodificao de uma instruo feita pela
mquina e quanto mais formatos existirem, mais possibilidades de
combinaes de bits existiro. Isto tem implicao direta no desempenho do
decodificador. Ento, a escolha de um pequeno nmero de formatos melhora o
desempenho da mquina.
Para finalizar, estudamos como a anatomia de um arquivo executvel
no formato ELF. O conhecimento adquirido ao dividir os campos das
instrues diretamente aplicado para o reconhecimento do formato ELF.
No nos cabe, entretanto, discutir os detalhes do formato. A apresentao foi
geral, mas com ela possvel extrair a maioria das informaes no formato.
Em particular uma seo muito especial precisa ser abordada: a seo de
cadeia de caracteres (strings).
Cada seo tambm tm nome e eles podem indicar um tipo muito
particular de seo. As sees mais conhecidas so: .init que contm um
trecho de cdigo que deve ser executado antes da chamada ao programa
principal; .text que contm as instrues do programa propriamente dito;
.fini, que executada depois da finalizao do cdigo do programa em
.text. .init e .fini executam instrues que contribuem para a criao
e finalizao do processo pelo Sistema Operacional. A seo .data contm
os dados do programa. A seo .rodata (read-ony data) contm os dados
que no sero passivos de escrita durante a execuo do cdigo. A seo
.strtab contm strings usadas no programa e a seo .symtab contm
informaes sobre os smbolos utilizados.
Juntado os nossos conhecimentos, aprendemos a criar uma descrio de
uma arquitetura em uma ADL, a ArchC. Fizemos um esboo de uma descrio
do MIPS usando a linguagem. Usamos um modelo funcional que esconde os
detalhes da organizao do computador, mas explicita os detalhes da
construo do conjunto de instrues. um bom exerccio completar a
especificao.
95

Usando o SPIM podemos observar como a codificao binria de cada
instruo que executamos, basta olhar a coluna que mostra o valor
hexadecimal equivalente.
Um outro exerccio com simuladores, envolve a prtica com o ArchC. O
leitor se sinta impelido a instalar o SystemC e o ArchC para poder fazer
simulaes de descrio de ISAs.
Por fim, o programa objdump pode ser til na decodificao
automtica (desassembler) de arquivos do formato ELF. Mas para ir alm
seria interessante usar um programa que apresente o cdigo hexadecimal de
cada byte de um arquivo, como o HexEdit.
3.7 Exerccios
3.1 Pesquise na web e produza um resumo sobre a seo strtab.
3.2 Pesquise na web e produza um resumo sobre como especificar pseudoinstrues do MIPS em ArchC.
3.3 Para cada cdigo criado nos exemplos do captulo 2 encontre a
codificao em linguagem de mquina do MIPS.
3.4 Preencha a Tabela 3.6 como o exemplo.
3.5 Dado o arquivo ELF a seguir, indique qual o programa que ser
carregado na memria para ser executado.
# byte
00000000
00000010
00000020
00000030
00000040
00000050
00000060
00000070
00000080
00000090
000000a0
000000b0
000000c0
000000d0
000000e0
7f
00
00
00
00
00
01
01
01
01
00
00
00
00
00
45
02
00
02
40
00
09
09
09
09
00
00
00
00
00
4c
00
00
00
00
00
58
50
58
50
00
00
00
00
00
46
08
a0
00
00
00
2a
22
2a
22
00
00
00
06
00
01
00
00
00
00
00
11
00
11
00
00
00
00
00
00
02
00
00
00
00
00
60
00
60
00
00
00
00
04
00
01
00
00
00
00
00
00
00
00
00
00
00
00
00
00
Contedo
00 00 00
01 00 40
00 00 34
01 00 00
18 00 00
00 00 00
03 01 09
00 00 00
03 01 09
00 00 00
00 00 00
00 00 00
00 00 00
00 00 00
00 00 00
00
00
00
00
00
00
50
00
50
00
00
00
00
00
00
00
00
20
60
18
00
20
00
20
00
00
00
01
80
04
00
00
00
00
00
00
08
00
08
00
00
00
00
00
00
00
00
01
40
00
00
10
00
10
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
00
34
28
00
07
00
05
00
05
00
00
00
01
18
00
96
Categoria
Nome Formato
add
Exemplo
Operao
(ArchC)
Comentrios
add rd, rs, rt
RB[rd] =
RB[rs] + RB[rt];
Overflow gera exceo
sub
Overflow gera exceo

Overflow gera exceo
entre 32.768 e +32.767
entre 0 e 65.535
operao
addi
addu
subu
Aritmtica
addiu
mul
lgicas
Transferncia
de dados
mult
multu
div
divu
or
and
xor
nor
andi
ori
sll
srl
sra
mfhi
mflo
lw
sw
Imediato em 16 bits
Imediato em 16 bits
Desloc. 32
Desloc. 32
Desloc. 32. Preserva sinal
Carrega constante na poro

alta do registrador de
destino.
Zera a parte baixa.
lui
Suporte a
deciso
bne
beq
j
Opera com nmeros
sinalizados
Opera com nmeros
no sinalizados
slt
sltu
Suporte a
procedimentos
jal
jr
Tabela 3.6: Instrues do MIPS
Captulo 4
O Processador
4.1 Introduo
Aprendemos at o presente a utilizar uma linguagem de montagem e
como esta linguagem convertida para linguagem de mquina, que
efetivamente inteligvel ao processador. Com os conhecimentos adquiridos
possvel descrever, no nvel funcional, o comportamento de uma mquina que
executa as instrues que ns projetamos. Este captulo tem a inteno de
mostrar como podemos projetar um hardware para tornar realidade um tal
processador de instrues.
Tambm introduziremos a questo do desempenho, que ser tratada de
forma mais abrangente no captulo 5. Aqui a abordagem ser meramente a
construo de um pipeline que permita que as instrues sejam executadas por
partes, promovendo uma melhor utilizao dos recursos e diminuindo o tempo
necessrio para execuo de um programa.
Finalmente veremos, na viso do software, como podemos especificar
uma organizao de um computador de forma mais sofisticada utilizando
ArchC.
4.2 Componentes da via de dados

Para construirmos uma via de dados capaz de executar as instrues que
ns projetamos preciso conhecer primeiro os componentes fundamentais de
uma organizao de computador. Ns j nos deparamos com o modelo de
memria como um grande repositrio de informaes endereveis. Como
descreveremos em detalhes o sistema de memrias no captulo 6, vamos
apenas considerar que uma memria uma caixa que possui duas informaes
97
98
de entrada: se haver uma leitura ou escrita; e qual o endereo ser

lido/escrito.
A Figura 4.1 mostra o modelo utilizado. Um sinal de controle W/R
indica se haver uma leitura (02) ou escrita (12). O endereo posto pelo
processador nos 32 bits que compem o endereo. No caso de uma leitura de
informao, o dado requerido disponibilizado nos 32 bits que compem a
entrada/sada da memria. No caso de uma escrita de informaes, o
processador disponibiliza o dado e o endereo onde ele deve ser escrito e
envia um sinal de escrita (W/R=12).
Mencionamos no captulo 1 deste livro que na memria existem duas
regies distintas: a de cdigo e a de dados. Esta distino meramente
convencionada, mas existem tcnicas que permitem a utilizao simultnea
das duas regies. Para o software como se existissem duas memrias
separadas. Vamos seguir este modelo no desenvolvimento do restante de
nossa construo da via de dados.
W/R
1
Endereo
32
Memria
32
Entrada/Sada
Informao
Figura 4.1: Representao de uma memria
O segundo componente da via de dados o banco de registradores. Ns

j sabemos que uma instruo, por exemplo, aritmtica l dois registradores e
escreve o resultado em terceiro registrador. Nosso banco de registradores ser
capaz de ler dois registradores ao mesmo tempo e escrever em um terceiro
(que pode inclusive ser um dos que acabou de ser lido).
A Figura 4.2 mostra o projeto de um banco de registradores. O sinal de
controle W/R anlogo ao presente na memria. Ele vai controlar leitura e
escrita no banco. As duas especificaes de registradores a serem lidos so
99
Captulo 4: O processador
feitas utilizando-se de 5 bits. Ora, com esta quantidade de bits possvel

enderear qualquer registrador em um banco de 32 registradores. Os dados
que esto armazenados nos respectivos registradores sero disponibilizados
em duas vias de 32 bits cada.
No caso de uma escrita, a informao do dado a ser escrito
disponibilizado e o sinal W/R setado, indicando uma escrita.
W/R
1
Reg. Leit. 1
Reg. Leit. 2
Reg, Escrita
5
5
5
32
Banco
Registrador
32
Dado 1
Dado 2
32
Dado para
Escrita
Figura 4.2: Representao de um banco de registradores
O terceiro e ltimo componente da via de dados a unidade lgica e

aritmtica. Este , certamente, o componente onde as operaes ocorrem. Ele
controlado por uma srie de sinais que indicam qual operao deve ser
realizada em um determinado instante. Soma, subtrao, and, or, slt etc.
Todas as operaes so realizadas com operandos de 32 bits. Apenas dois
operandos so utilizados por vez. O resultado da operao tambm dado em
32 bits. Existe ainda um bit de sada, informando se o resultado da operao
realizada zero. Este sinal chamado de resultadozero.
A Figura 4.3 mostra uma ALU tpica para um conjunto de instrues
bem restrito (mais ainda do que aquele que apresentamos nos captulos
anteriores). Existem 3 sinais de controle (op) para informar qual a operao a
ser realizada. Dado 1 e Dado 2 sero os operandos e o resultado ficar em
resultado. ResultadoZero valer 12 se o resultado da operao, seja
ela qual for, valer 02.
100
ALUop
3
32
Dado 1
ResultadoZero
Resultado
32
32
Dado 2
Figura 4.3: Representao de uma ALU
Existem ainda dois componentes muito importantes, mas que servem

como interligao entre estas partes principais. O extensor de sinal um
destes componentes. Como j dissemos, a ALU opera sempre com dados de
32 bits, mas as instrues do tipo I portam em sua codificao, dados de 16
bits. preciso convert-los para 32 bits para que possam ser operados pela
ALU. Agora, a ttulo de recordao, vamos ver como um nmero negativo
representado em diversas quantidades de bits. Por exemplo, o nmero -2 em
16 bits vale 11111111111111102. J em 32 bits este valor representado
como, 111111111111111111111111111111102. Transformar um dado de 16
bits em 32 bits simplesmente replicar o seu bit de sinal para as 16 casas
binrias que restam nos 32 bits. Isto tambm funciona perfeitamente com
nmeros positivos. A Figura 4.4 mostra um extensor de sinal de 16 bits para
32 bits.
Finalmente temos o multiplexador, MUX. Este circuito funciona como
um seletor de canais, controlado eletronicamente. Um MUX com 4 canais
implica em um seletor de 2 bits. Um MUX com 8 canais, em um seletor de 3
bits. A Figura 4.5 mostra a operao de um MUX com 4 canais. Observe que
os canais no necessariamente possuem apenas um bit. A propsito, na figura
so mostrados canais de 32 bits.
16
Extensor
de sinal
32
Figura 4.4: Extensor de sinal (16 bits para 32 bits)
101
Canal
0 1 2 3
Canal
0 1 2 3
002
seleo
Canal
0 1 2 3
012
seleo
MUX
Canal
0 1 2 3
MUX
32
102
seleo
32
sada
112
seleo
MUX
MUX
32
sada
32
sada
sada
Figura 4.5: Operao de um MUX
4.3 Interligao dos componentes da via de dados

Agora que j conhecemos os componentes que compem a via de dados
e os seus funcionamentos, vamos interlig-los de tal forma que possamos
realizar as instrues do MIPS. Por simplicidade, vamos trabalhar com um
pequeno subconjunto de instrues.
Vamos comear pela implementao da via de dados para realizar a
instruo add $8, $9, $10. Bem, preciso fazer duas leituras no banco
de registradores, realizar a soma na ALU e escrever o resultado de volta no
banco de registradores. A Figura 4.6 mostra a interligao dos componentes
para formar a via de dados. A instruo a ser executada est em um registrador
especial chamado IR. A partir dele os campos dos registradores so extrados.
ALUop
function
W/R
1
32
5
sa
rd
Banco
10
Registrador
rt
Dado 1
Dado 2
32
ResultadoZero
Resultado
32
32
Dado para
Escrita
rs
Opcode
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
IR
Figura 4.6: Via de dados para instruo add
102
Os registradores especificados em rs e rt so lidos do banco de

registradores. O dados vo direto para as entradas da ALU, onde a operao
de soma selecionada e o resultado disponibilizado para escrita de volta no
banco de registradores. Esta escrita ser realizada no registrador especificado
no campo rd da instruo. Os sinais de controle sero estudados
oportunamente.
Agora vamos ver como seria a via de dados para execuo da instruo
lw $8, 16($4). Nesta instruo, so utilizadas: a memria, para leitura do
dado; o banco de registradores para ler $4 e escrever o dado retirado da
memria em $8; e o extensor de sinais para converter o campo imediato da
instruo em um valor de 32 bits. Este valor ser somado na ALU com o
contedo do registrador $4 para formar o endereo do dado a ser lido. A
Figura 4.7 mostra esta nova via de dados.
immediate
32
4
5
5
Banco
Registrador
rt
ResultadoZero
Dado 1
32
32
32
Endereo
Extensor
de sinal
rs
16
1
5
W/R
ALUop
W/R
Opcode
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
IR
Dado para
Escrita
Memria
32
Entrada/Sada
Informao
Figura 4.7: Via de dados para instruo lw
Agora vamos ver uma parte da via de dados que comum a todas as
instrues: o clculo de PC e a busca de instrues na memria. Em verdade,
o PC sempre somado a 4, salvo em caso de instrues de salto. Vamos
considerar inicialmente que no existem saltos e verificar como ficaria o
circuito para calcular o PC. Ora, j sabemos que a ALU capaz de realizar
somas, subtraes, operaes lgicas etc. Uma ALU mais simples, que realiza
apenas somas com o valor 4, ento utilizada para clculo do PC. O valor do
PC incrementado e a instruo seguinte lida na memria. A Figura 4.8
mostra esta parte do circuito.
103
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
PC
W/R
1
Memria
32
32
+
4
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
IR
Figura 4.8: Clculo do PC e busca de instrues na via de dados
Finalmente vamos verificar como ficaria a via de dados para podermos

realizar uma instruo beq $8, $9, alvo. Sabemos que esta instruo
compara $8 com $9 e se eles forem iguais salta para o endereo representado
por alvo. O clculo do endereo envolve somar o valor de PC com o valor do
campo imediato da instruo (multiplicado por 4) para encontrarmos o novo
valor de PC. Entretanto, este valor calculado de PC s ser gravado no mesmo
se a condio para o salto acontecer.
Ento uma parte da via de dados precisa se certificar que $8 e $9 so
iguais. Bem, para saber se dois nmeros so iguais basta subtrair o primeiro
do segundo. Se o resultado for 0, significa que os dois nmeros so idnticos,
caso contrrio eles diferem. Uma boa opo seria utilizarmos a ALU principal
para fazer esta operao e mais uma vez utilizarmos uma outra ALU menor,
que realiza apenas somas, para clculo do alvo do desvio.
A Figura 4.9 mostra como ficaria a via de dados para dar suporte a esta
instruo. Veja que o valor de PC pode ser tanto PC+4 como o endereo alvo
calculado usando o campo immediate da instruo e o prprio PC. Para
selecionar uma das duas possibilidades usamos um MUX. O sinal de seleo
do MUX vem exatamente da ALU principal. Se a comparao (subtrao)
resultar em um valor 1, ou seja, se os operandos forem idnticos, ento
selecionado como novo valor de PC o endereo do alvo. Caso contrrio, o PC
simplesmente incrementado de 4. Ainda, o clculo do endereo envolve uma
multiplicao por 4 que implementada com um deslocador de 2 posies.
104
Resultadozero
PC
32
Memria
32
4
M
U
X
ALUop
W/R
1
32
immediate
5
8
5
5
Banco
Registrador
32
9
rt
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
16
rs
W/R
Opcode
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Extensor
de sinal
<<2
32
Endereo
alvo
IR
Figura 4.9: Via de dados para instruo beq
At o presente projetamos vias de dados particulares para cada

instruo. Observe, entretanto, que algumas ligaes entre as partes so
comuns a mais de uma instruo. Para evitar desperdiar recursos de hardware
vamos tentar reaproveitar os componentes e suas interligaes. Vamos por
exemplo projetar uma via de dados que execute tanto a instruo add como a
instruo lw.
Observando as figuras 4.6 e 4.7 vamos perceber que a primeira
diferena entre as duas refere-se segunda entrada da ALU (doravante
usaremos apenas ALU para designar ALU principal). Ela pode vir do Extensor
de sinal ou do banco de registradores. Outra escolha que precisa ser feita
quanto ao dado a ser escrito no banco de registradores. Ou ele vem da
memria, ou ele vem da ALU. Finalmente a terceira diferena refere-se a qual
campo da instruo especifica o registrador onde, o resultado da soma ou a
carga do dado, ser escrito. Para fazer estas escolhas podemos utilizar MUXs
controlados por sinais de seleo vindos da unidade de controle. A Figura 4.10
mostra como feita a fuso das duas vias de dados em apenas uma.
105
function
sa
Banco
Registrador
5
5
rt
rd
32
Dado 2
ResultadoZero
Resultado
32
32
Dado para
Escrita
rs
Opcode
Dado 1
32
IR
immediate
32
Banco
Registrador
5
5
1
5
W/R
ALUop
W/R
ResultadoZero
Dado 1
32
32
Endereo
rt
32
Extensor
de sinal
Opcode
function
Dado para
Escrita
IR
Entrada/Sada
Informao
sa
rd
M
U
X
Banco
Registrador
32
Dado 1
32
Dado 2
ResultadoZero
1
32
ALUsrc
Memria
16
IR
W/R
ALUop
W/R
REGsrc
Memria
32
rs
16
rt
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
rs
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
ALUop
W/R
5
Opcode
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Extensor
de sinal
Dado para
Escrita
M
U
X
32
REGdata
32
1
M
U
X
Entrada/Sada
Informao
Figura 4.10: Via de dados para instrues add e lw
106
Agora, quando a instruo a ser executada for uma soma os sinais de

controle devem refletir esta escolha, ou seja, REGdst = 02, REGdata = 02 e
ALUsrc = 02. Ao contrrio, quando a instruo for uma lw, os sinais de
controle devem ser: REGdst = 12, REGdata = 12 e ALUsrc = 12.
A fuso desta nova via de dados com aquela projetada para instruo
beq tambm muito simples. Nenhum novo MUX acrescentado, somente o
clculo de PC e a carga da instruo. A Figura 4.11 ilustra a nova via de
dados. Perceba que a memria foi dividida em memria de instrues e
memria de dados. Esta diviso lgica implementada na prtica atravs do
uso de duas caches. Estudaremos a hierarquia de memrias mais tarde.
Um outro componente acrescentado na via de dados foi a porta AND.
Ora, imagine que esta via de dados est realizando uma soma de dois valores
iguais a zero. O resultado seria zero e a ALU setaria a sada
ResultadoZero. Isto faria com que o PC fosse carregado com um valor
qualquer. Esta sada da ALU s tem significado quando a instruo a ser
executada for uma beq, por isto a porta AND e o sinal de controle BEQ?
foram acrescentados.
Agora que j conhecemos a metodologia para acrescentar
funcionalidades via de dados, resta-nos pensar em como implementar as
demais instrues que estudamos. O caminho sempre montar uma via de
dados para a instruo em particular e depois anex-la com as demais.
32
4
M
U
X
function
REGdst
sa
rd
M
U
X
Banco
Registrador
16
IR
32
Dado 1
32
Dado 2
W/R
1
32
ALUsrc
Memria
Dados
rt
Memria
Instrues
32
ALUop
W/R
rs
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Opcode
W/R
ResultadoZero
BEQ?
PC
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Extensor
de sinal
M
U
X
REGdata
32
<<2
32
1
M
U
X
Figura 4.11: Via de dados para instrues add, lw e beq
107
4.4 Unidade de controle

A Unidade de Controle responsvel por gerar os sinais de deciso para
a via de dados, a fim de promover a correta execuo das instrues. Alm dos
sinais de controle dos MUXs, ainda existem outros sinais de controle nas
unidades que compem a via de dados. O sinal de escrita nas memrias e no
banco de registradores e o sinal BEQ?.
Para decidir quais sinais de controle devem ser setados e quais devem
ser ressetados preciso conhecer a instruo que se pretende executar. Para
isto a unidade de controle l o campo opcode e o campo function e a
partir deles gera os sinais adequados.
Vamos exemplificar como seria construda a unidade de controle para
as trs instrues utilizadas acima na construo da via de dados. Por razes
de simplicidade vamos considerar que as memrias e o banco de registradores
esto sempre lendo e no momento em que precisam escrever um dado que o
sinal de escrita deve ser setado. Vamos tambm considerar que para a ALU
realizar uma soma, os dados a serem inseridos em ALUop valem 0102 e para
que seja realizada uma subtrao ALUop deve conter 1102.
A forma mais simples de construir esta unidade de controle gerar uma
tabela verdade com todas as entradas e sadas. A unidade de controle seria
modelada como um circuito combinacional simples. Na prtica, as unidades
de controle so microprogramadas ou hardwired. Para nossa abordagem
poderamos esquecer os detalhes de implementao e devotar o nosso tempo
escolha dos sinais de controle adequados para cada instruo.
A Tabela 4.1 mostra a tabela verdade implementada na unidade de
controle para as nossas instrues. Os sinais de controle so ento setados de
acordo com a necessidade de cada instruo. W/R REG, por exemplo, vale 12
quando a instruo precisar escrever no banco de registradores. W/R MD vale
12 se for necessrio escrever na memria de dados (caso da instruo sw, no
exemplificada at o presente). Observe que o sinal W/R MI deve ser sempre
02, pois no h sentido, para um usurio, escrever na memria de instrues.
Entradas
instruo
opcode
function
add 000000 100000

lw 100011 XXXXXX
beq 000100 XXXXXX
Sadas
W/R
MI
0
0
0
REGdst
0
1
0
W/R
REG
1
1
0
ALUsrc
BEQ?
REGdata
ALUop
0
1
0
0
0
1
0
1
0
010
010
110
Tabela 4.1: tabela verdade da unidade de controle
W/R
MD
0
0
0
108
M
U
X
Extensor
de sinal
Memria
Dados
M
U
X
32
<<2
W/R
MD
ResultadoZero
ALUsrc
REGdata
16
IR
ALUop
W/R
REG
REGdst
function
sa
Banco
Registrador
rt
rd
M
U
X
rs
Memria
Instrues
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Opcode
W/R
MI
PC
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
BEQ?
Unidade
de
Controle
M
U
X
Figura 4.12: Via de dados com Unidade de Controle para instrues add, lw e beq
A Figura 4.12 mostra como a unidade de controle se acopla ao hardware

da via de dados. medida que novas instrues vo sendo implementadas
novos MUXs vo surgindo e a complexidade aumentando. Isto significa que a
unidade de controle, que realiza a decodificao (interpretao da instruo),
vai ficando mais e mais difcil de ser implementada com lgica
combinacional.
Esta nossa implementao, embora funcional, carece de uma importante
varivel: o tempo. Neste modelo todas as instrues gastam o mesmo tempo
para serem executadas. Esta implementao chamada monociclo. O ciclo a
que se refere o nome o ciclo de clock. O clock uma onda quadrada que
atua como uma espcie de maestro das tarefas de um processador. Ele dita em
quanto tempo uma tarefa executada. A freqncia do clock o inverso do
ciclo de clock. Isto significa que quanto mais alta a freqncia, mais
instrues o processador ser capaz de realizar em um determinado intervalo
de tempo.
A busca da tecnologia por freqncias mais altas esbarra em um efeito

colateral muito indesejado: a dissipao de potncia em forma de calor. Hoje
um processador opera com um ventilador (cooler) acoplado a ele para permitir
que ele opere em freqncias mais altas.
4.5 Via de dados mono e multi-ciclos

parte destas implicaes vamos ver como a nossa via de dados sofre a
influncia desta nova varivel. Nossa implementao no se importou com os
atrasos em cada componente do circuito, mas de fato, eles existem. Por
exemplo, a leitura nas memrias pode custar 6ns, enquanto o acesso ao banco
de registradores custa 2ns. A ALU realiza uma operao em 4 ns. O tempo de
leitura e escrita nos registradores PC e IR so desprezveis e tambm o tempo
para as somas nas ALUs auxiliares.
Para estes nmeros, por exemplo, o clico de clock seria: 6ns (acesso a
MI) + 2ns (Leitura REG) + 4ns (ALU) + 6ns (acesso a MD) + 2ns (escrita no
REG) = 20ns. Ou seja, mesmo que uma instruo no utilize todos os
componentes da via de dados, preciso garantir que o ciclo de clock acomode
a execuo de qualquer instruo. Nesta situao, o pior caso quem dita a
regra. A freqncia de operao desta mquina no poderia ser maior que 50
MHz, um valor longe de nossa realidade atual (de cerca de 3GHz).
Uma possibilidade para melhorar estas perdas seria utilizar uma
abordagem multiciclos. Neste caso o ciclo de clock seria a menor unidade de
tempo necessria para realizar uma tarefa em qualquer dos componentes da
via de dados, ou seja, poderamos, no exemplo acima, especificar o ciclo de
clock como sendo 2ns. Seriam necessrios ento 3 ciclos de clock para acesso
memria e 2 ciclos de clock para operao da ALU. As operaes de leitura
e escrita no banco de registradores consumiria apenas 1 ciclo de clock cada.
Agora, instrues que no utilizam todos os componentes da via de dados
poderiam terminar sua execuo mais rapidamente (em menos ciclos).
Infelizmente existem alguns requisitos para que esta idia possa se
tornar realidade. Precisamos dividir as tarefas do processador para executar
uma instruo em etapas. A primeira seria buscar a instruo na memria
(Instruction Fetch). A segunda seria decodificar esta instruo e ler os
registradores adequados (Instruction Decode). Depois seria feito o envio dos
dados para a ALU (instruction issue) e sua seqente execuo (Instruction
Execution). Em alguns casos seria necessrio ler ou escrever um dado na
memria (Memory Access) e finalmente seria necessrio escrever o dado lido
no banco de registradores (Write-Back). Estas cinco etapas precisariam ser
blindadas em hardware para que o clock pudesse comandar as atividades de
109
110
cada uma delas. Esta blindagem feita utilizando-se de registradores entre

estgios de execuo. Deste ponto em diante j no vamos mais tecer detalhes
sobre a implementao, bastando ao leitor o entendimento dos conceitos e das
implicaes em adot-los. Naturalmente sintam-se encorajados a saber mais
em uma literatura mais volvida para organizao de computadores.
Vamos analisar as vantagens, em termos de tempo, de uma
implementao multi-ciclo sobre uma mono-ciclo. Considerando uma
seqncia de instrues, add, lw e beq e sabendo que na abordagem monociclo cada instruo executada em 20 ns, precisaramos de 60ns para que
esta seqncia fosse terminada. Numa abordagem multi-ciclo a instruo add
utiliza 7 ciclos de 2ns cada, ou seja, ela consome 14ns. lw precisa passar por
todas as etapas e portanto utiliza os mesmos 20ns como no original. beq
utiliza 6 ciclos de 2ns, ou seja 12ns. A execuo das 3 em um sistema multiciclos demanda apenas 46 ns.
A Figura 4.13 mostra a execuo das instrues nas duas abordagens.
Veja que a execuo da instruo add passa pela memria de instrues,
banco de registradores, ALU e banco de registradores. lw utiliza memria,
banco de registradores, ALU, memria e banco de registradores. beq utiliza
memria, banco de registradores e ALU.
Mono-ciclo
add
beq
lw
add
lw
beq
Multi-ciclo
tempo
20ns
40ns
60ns
Figura 4.13: Execuo de instrues em implementaes mono e multi-ciclos
Poderia existir ento algum mtodo mais rpido para executar

instrues que a implementao multi-ciclos? A resposta sim, fazendo
111
reutilizao dos componentes presentes em cada parte da execuo da

instruo.
4.6 Pipeline
A idia por trs do pipeline uma linha de montagem de automveis.
Enquanto o uma equipe est trabalhando na pintura, outra est trabalhando no
sistema eltrico e outra no motor. Quando as trs equipes terminam sua tarefa,
o primeiro carro est totalmente montado, o segundo, que estava na parte
eltrica, vai para a parte de pintura, e o terceiro, que estava no motor vai para
parte eltrica. Assim, podemos manter ocupadas todas as partes de um
processador sem precisar esperar que a instruo fique pronta.
A diviso do trabalho feita de forma semelhante ao mostrado
anteriormente: um estgio de busca (F, fetch), um de decodificao (D,
decode), um de execuo (E, execution,), um de memria (M, memory) e o
ultimo de escrita (W, write). Nesta abordagem, a equipe (o estgio do
pipeline) mais lenta quem dita a regra.
Seguindo a mesma temporizao dos exemplos anteriores poderamos
definir um ciclo de clock de 6ns, pois a leitura da memria a parte mais
demorada do processo e gasta exatamente 6ns. Durante o primeiro ciclo de
clock a instruo add buscada na memria. No segundo ciclo de clock, a
instruo add vai para o estgio de decodificao e a instruo lw buscada
na memria. No terceiro ciclo de clock, add vai para execuo, lw vai para
decodificao e beq buscada na memria. E assim, sucessivamente. A
Figura 4.14 mostra a execuo das instrues.
Fadd
Dadd
Flw
Eadd
Madd
Wadd
Elw
Mlw
Wlw
Ebeq
Mbeq
Dlw
Fbeq
Dbeq
18ns
Wbeq
36ns
Figura 4.14: Execuo de instrues em pipeline
tempo
54ns
60ns
112
Agora a execuo foi concluda com 42ns. Melhor que a implementao

multi-ciclo. Esta vantagem se amplia muito se considerarmos que outras
instrues vo entrando no pipeline e a tendncia que tenhamos uma
instruo terminada a cada 6ns, uma taxa prxima de 1 instruo por ciclo de
clock (IPC, Intruction Per Cicle).
Apesar destes avanos, vamos perceber na viso do software que o
pipeline sofre um mal que exige muita ateno: a dependncia de dados..
A viso do software
4.7 A viso do software O pipeline

O pipeline parece ser uma grande vantagem em termos de desempenho
para os processadores. Entretanto existem algumas dificuldades que tornam
a aplicao do pipeline um pouco menos eficiente que o limite terico. Vamos
ver um exemplo bastante simples. Depois de executar algumas instrues o
pipeline mostrado na Figura 4.15 pretende ao mesmo tempo escrever no
banco de registradores para instruo add e ler o banco de registradores
para instruo sub.
Ora, isto gera um conflito de recursos. O meu banco de registradores
capaz de ler duas instrues por vez, mas no est projetado para ler e
escrever ao mesmo tempo. Um conflito de recursos definido como sendo a
tentativa de utilizao de um mesmo componente por mais de uma instruo
ao mesmo tempo.
Neste caso especfico, como a leitura no banco de registradores ocorre
em 2ns e o ciclo de clock de 6ns, conforme o exemplo que ns estamos
trabalhando desde o incio de nossa abordagem, possvel fazer uma escrita
e uma leitura dos dados dentro do mesmo perodo do clock. Ento, utilizada
a primeira metade do ciclo de clock para escrita no banco de registradores e
a segunda metade para fazer as leituras. Poderia ser ao contrrio, mas assim
mais eficiente.
Um segundo problema a ser enfrentado neste pipeline a dependncia
de dados. Observe que o simples trecho de cdigo abaixo gera um enorme
problema para o pipeline.
add $8, $9, $10
sub $11, $12, $8
Aqui a instruo sub utiliza o resultado da instruo add como um de
seus operandos. Ora, pensando em pipeline, o resultado de add s vai estar
pronto no quinto ciclo de clock, mas sub precisa dele j no terceiro ciclo de
113
clock. Este tipo de conflito ns chamamos de conflito de dados. Ele est

ilustrado na Figura 4.16.
Fadd
Dadd
Flw
Eadd
Dlw
Fbeq
Madd
Wadd
Elw
Mlw
Wlw
Ebeq
Mbeq
Wbeq
Esub
Msub
Dbeq
Fsub
Dsub
Wsub
Figura 4.15: Dependncia Estrutural no pipeline
Dadd
Fsub
Eadd
Dsub
Madd
Wadd
Esub
Msub
Wsub
Figura 4.16: Dependncia de dados no pipeline
Por fim, existe ainda um tipo de conflito muito comum: conflito de

controle. Imagine a execuo de uma instruo de salto. Como o processador
s vai saber se a condio de salto foi atingida ou no no estgio de
execuo, duas instrues que seguem no pipeline nos primeiros estgios
podem correr o risco de serem descartadas. Se o salto for tomado,
certamente haver penalidades por isto. A Figura 4.17 mostra um beq que se
fosse tomado deveria executar a prxima instruo sw e se no o fosse
seguiria com lw. Como o teste s foi realizado no final do estgio de
A viso do software
Fadd
114
execuo, as duas instrues que vinham aps foram descartadas e a

instruo correta passou a ser buscada.
Fbeq
Dbeq
Flw
Ebeq
Mbeq
Wbeq
Fsw
Dsw
Dlw
Fsub
A viso do software
Figura 4.16: Dependncia de controle no pipeline
Apesar destas dificuldades existem tcnicas que buscam resolver o

problema e praticamente o eliminam. As tcnicas de forwarding e de delay
slot so muito eficazes para solucionar conflitos. Uma outra tcnica para
melhorar o desempenho usar um circuito preditor de desvio. Este circuito
memoriza se um salto foi tomado ou no e caso ele tenha sido tomado
freqentemente, a instruo que ser retirada da memria aps a instruo
do salto ser que se encontra em seu endereo alvo e no a sua subseqente.
Conhecer os conflitos gerados nos pipelines podem nos ajudar a
programar melhor em HLL. A primeira dica tentar evitar o uso de
instrues que dependam imediatamente do resultado da anterior. A segunda,
construir estruturas de controle como laos de tal forma que eles sejam o
mximo possvel uniforme, ou seja, que sempre tome um caminho, variando
muito pouco o seu comportamento. Construir estruturas de deciso que ficam
alternando os caminhos de processamento das instrues perder
desempenho.
4.8 Concluses
Estudamos neste captulo a construo de um processador simples capaz
de executar as instrues em cdigo de mquina vistas no captulo anterior.
Vimos tambm que existem algumas maneiras de interligar os componentes
de um processador de tal forma que obtenhamos o melhor desempenho
possvel. A propsito, as mtricas de desempenho sero abordadas em nosso
prximo captulo.

O EWB uma ferramenta interessante para construo de circuitos. A
prtica com este simulador leva o leitor a conhecer bem o material do curso.
Ns propomos aqui dois projetos. A construo de uma ALU com portas
lgicas e igualmente a construo de um banco de registradores. Depois tente
interconect-los.
4.10 Exerccios
4.1
Pesquise na web e produza um resumo sobre unidade de controle

microprogramada.
4.2 Pesquise na web e produza um resumo sobre unidade de controle
hardwired.
4.3 Pesquise na web e produza um resumo sobre forwarding em pipelines.
4.4 Pesquise na web e produza um resumo sobre delay slots em pipelines.
4.5 Crie um via de dados para executar a instruo sw.
4.6 Anexe a via de dados criada no exerccio 2.5 na via de dados mais
completa apresentada neste captulo.
4.7 Crie um via de dados para executar a instruo j.
4.9 Crie um via de dados para executar a instruo jal.
4.11 Crie um via de dados para executar a instruo addi.
115
116
Captulo 5
Desempenho do
Computador
5.1 Introduo
Retomando nossa trajetria de leitura, ns j descobrimos os
componentes bsicos de um computador, a sua linguagem de montagem e de
mquina e uma implementao em formato simples. A propsito, discutimos
trs possibilidades de implementao (mono-ciclo, multi-ciclo e pipeline).
Conclumos que a abordagem pipeline nos permite terminar um programa em
menos tempo e assim inferimos que a mesma a melhor.
A discusso sobre o desempenho apenas comeou. Vamos, neste
captulo, trabalhar com algumas mtricas de desempenho utilizadas para
afirmar que uma mquina melhor que outra. Um cuidado extremo preciso
para ter tal afirmao creditada alm do imaginrio promovido pela mdia. A
propsito, vender produtos significa torn-los necessrios aos olhos do
comprador, mesmo que seja por uma iluso de tica. A ressalva mesmo
feroz em nosso mundo competitivo. Um vendedor ilibado provavelmente teria
dificuldades de vender um produto sem fazer uso de apelos comerciais. No
nos cabe discutir a tica de comrcio, ento vamos parar com nossa analogia
por aqui, sem atingir um ponto de discrdia com profissionais do ramo.
Para comear a discusso, vamos primeiro tentar enxergar o tamanho do
problema que se nos apresenta. Imagine um sistema com diversos
processadores lentos sendo comparado com um sistema com um nico
processador rpido. O segundo provavelmente termina uma tarefa bem antes
que qualquer dos componentes do primeiro, mas este tem capacidade de
processar mais informao (em paralelo) por intervalo de tempo.
E ento, qual dos dois melhor? A resposta para esta pergunta
frustrante. Ela : depende!. Se muitas tarefas so usadas simultaneamente
provavelmente o primeiro sistema melhor, mas se poucas tarefas so usadas,
o segundo sistema pode ser melhor. Dizemos que o primeiro sistema tem
117
118
maior throughput do que o segundo. Do ponto de vista do usurio, a mtrica

de melhor ou pior est fortemente associada ao fato de uma tarefa executar
mais rpido. Por isto, neste captulo estaremos avaliando como melhorar o
tempo de execuo de um programa.
O tempo total que um usurio gasta desde o comando para executar uma
tarefa at a sua concluso chamado de tempo decorrido (elapsed time).
Dentro deste tempo esto includas operaes de entrada e sada de dados,
acessos a servios do sistema operacional, tempo de espera por respostas das
memrias e o tempo efetivamente utilizado para o processamento pela CPU. A
Figura 5.1 ilustra esta diviso. O tempo de CPU (CPUtime) o tempo que a
CPU utiliza efetivamente para executar um determinado processo. Este tempo
pode ser muito pequeno se comparado com o tempo decorrido.
Alm disto, em sistemas operacionais multi-tarefas o tempo de CPU
distribudo para diversos processos o que torna menor ainda o tempo de CPU
dedicado a um processo. Este tempo de CPU pode variar guiado por trs
fatores: quantidade de instrues do programa; freqncia de operao do
processador; e a quantidade mdia de ciclos por instruo, CPI.
Quando implementamos a via de dados e o controle para executar
algumas instrues do MIPS, trabalhamos com um varivel importante: o
perodo do clock. O clock o relgio do sistema responsvel pela sincronia
entre os componentes do processador. Ele uma onde quadrada com ciclo de
trabalho ligeiramente diferente de 50%. O ciclo do clock o perodo desta
onda medido em segundos. A freqncia de operao do processador o
inverso do ciclo de clock.
SO
Memria
Entrada
CPU
CPU
CPU
CPU
Sada
tempo
Figura 5.1: Tempo decorrido de uma tarefa
119
Captulo 5: Desempenho do Computador
Quando estudamos pipeline percebemos que idealmente poderamos ter

uma instruo sendo terminada em cada ciclo de clock (aps uma certa
quantidade de instrues terem sido executadas). A tendncia ento que
tenhamos uma quantidade de ciclos por instruo muito prxima a 1. A
realidade muito mais cruel. Tipicamente para mquinas RISC este valor
chega a 1,5 e para mquinas CISC este valor fica prximo a 4. Quanto menor
este valor mais rpida ser a execuo do programa.
A quantidade de instrues necessrias para montar um determinado
algoritmo inversamente proporcional complexidade de suas tarefas. Isto ,
quanto mais complexo o conjunto de instrues, menos precisamos de
instrues para confeccionar um programa. S para darmos um exemplo
bsico, imagine que exista uma instruo addm $8, $9, ($10), onde um
dos operando da soma se encontra na posio de memria apontada por $10.
Esta uma instruo bem mais complexa que uma soma de valor armazenados
em registradores (pense da implementao da via de dados). Ora, em nossa
arquitetura MIPS seriam necessria duas instrues: lw $11, 0($10) e
add $8, $9, $11. As instrues so mais simples, mas gastam mais
espao nos programas para sua implementao equivalente.
Bem, agora que conhecemos as partes que influenciam o tempo de
CPU, vamos montar a equao fundamental da medida de desempenho do
processador.
Tempo de CPU =
Tempo
Ciclo
Ciclos
Instrues
Instrues
Programa
Esta equao norteia todo o clculo de desempenho da CPU. Existem

muitas tcnicas para melhorar cada um destes fatores, ou seja, diminu-los. Os
modelos RISC investem pesadamente me diminuir Ciclos/Instrues,
enquanto modelos CISC investem em reduzir o nmero de instrues por
programa. A varivel tempo/ciclo um fator tipicamente guiado pela
tecnologia de fabricao.
Outra coisa de fundamental importncia saber que estas variveis no
so to independentes assim. s vezes, modificar o hardware para alterar o
nmero de ciclos por instruo tambm interfere no tamanho do ciclo do
clock.
A varivel ciclos por instruo uma medida dinmica, ou seja, no
intrnseca ao processador e sua arquitetura. Para cada programa existe um
valor que deve ser medido. Com vrias medidas possvel calcular uma mdia
e estimar o CPI, mas havero cdigos em que ele no ficar sequer prximo
120
mdia. Naturalmente existem tcnicas, como regularidade de decodificao,

que ajudam a obteno de CPI baixos.
Vamos ver um exemplo hipottico para que o leitor tenha uma melhor
fixao do assunto. Para um determinado programa, uma mquina A possui
um CPI de 1,2 ciclos/instruo. Uma mquina B possui, para o mesmo
programa, um CPI de 2,4 ciclos/intruo. Este programa, para mquina A,
necessita de 128 instrues, enquanto para mquina B ele precisa de 80
instrues. Queremos saber qual a relao entre as freqncias das mquinas
para que as mesmas tenham o mesmo desempenho.
Considerando que o tempo de CPU deve ser igual temos:
Tempo CPUmaq.A = Tempo CPUmaq.B
Tempo
Ciclo
Ciclos
Instrues
Instrues
Programa
maqA
Tempo
Ciclo
Ciclos
Instrues
Instrues
Programa
maqB
Tempo/CiclomaqA. 1,2 .128 = Tempo/CiclomaqB. 2,4 . 80

2,4 . 80
Tempo/CiclomaqA
=
1,2 .128
Tempo/CiclomaqB
Tempo/CiclomaqA
= 1,25
Tempo/CiclomaqB
Tempo/CiclomaqA =1,25 . Tempo/CiclomaqB
1
1
= 1,25 .
FreqnciamaqA
FreqnciamaqB
FreqnciamaqB = 1,25 . FreqnciamaqA
Portanto conclumos que a freqncia da mquina B precisa ser 25%
maior que a freqncia da mquina A.
A freqncia de uma mquina (com pipeline) depende do estgio do
pipeline que tem o maior atraso. Recordemos o exemplo da Figura 4.14. Nele,
afirmamos que o ciclo do clock deveria ser de 6ns. Isto significa que quanto
maior a quantidade de dispositivos eletrnicos em um estgio do pipeline,
menor ser a freqncia da mquina. No exemplo da comparao de
121
freqncias entre as mquinas A e B, recm desenvolvido, temos a mquina A

com valores tpicos de RISCs e a mquina B com valores tpicos de CISCs.
Ora, o que se conclui do exemplo que a freqncia de um CISC precisa ser
maior que a freqncia de um RISC para que ambos tenham o mesmo
desempenho. Acontece que, nos RISCs, os estgios de pipeline realizam
menos tarefas que nos CISCs o que teoricamente beneficia o aumento de sua
freqncia.
Infelizmente nossa concluso apenas parcial, uma vez que, como visto
na Figura 5.1, o tempo de CPU no significa o tempo total que o usurio
necessita para executar sua tarefa. A propsito, hoje, o tempo que a memria
leva para responder ao processador determinante no desempenho da
mquina. Isto posto, e considerando que as mquinas CISCs normalmente
apresentam maior densidade de cdigo, em tese, elas so menos susceptveis
s baixas velocidades da memria. Isto poderia at mesmo inverter o quadro
do desempenho das mquinas, tornando a CISC mais veloz que a RISC.
Enfim, a concluso mais interessante que deveramos codificar e
armazenar na memria programas tipo CISC e executar programas tipo RISC.
Existem tcnicas para isto que esto em desenvolvimento e algumas em uso,
com tradutores de instrues CISCs em RISCs.
De volta discusso matemtica sobre as vantagens de um processador
sobre outro definimos o speedup como sendo a razo entre o desempenho de
uma mquina A e o desempenho de uma mquina B.
Speedup =
desempenhomaqA
desempenhomaqB
Ora, o desempenho de uma mquina composto de diversos fatores

tempo de CPU, tempo de resposta da memria, entrada e sada etc. Ns
costumamos simplificar a equao acima para apenas a componente do tempo
da CPU.
Speedup =
Tempo CPUmaqB
Tempo CPUmaqA
De fato poderamos extrapolar o conceito de speedup para qualquer

parte dos componentes de um desempenho, entretanto preciso saber
exatamente qual a influncia deste componente no tempo final de execuo
(tempo decorrido) para um programa. Uma melhoria de 50% em alguma das
122
variveis que compem este tempo, no significa uma melhoria de 50% no

desempenho da mquina.
Em 1967, George Amdahl quantificou suas observaes sobre o
fenmeno e derivou uma frmula conhecida Lei de Amdahl. Em essncia, a
Lei de Amdahl define que o speedup de um sistema depende do speedup de
um componente em particular, mas tambm da frao do tempo que este
componente usado pelo sistema. A frmula a seguinte:
Speedup =
1
(1 f) + f / k
onde f a frao do tempo utilizada pelo componente em particular; e

k o speedup do componente em particular.
Vamos a um exemplo simples: Um sistema computacional passa 70%
do seu tempo usando a CPU e os 30% restantes em disco. Uma nova CPU que
executa os mesmos programas e que tenha 1,5 vezes a freqncia da anterior
vai tornar o seu computador quantas vezes mais rpido?
Considerando que a CPU mudou apenas sua freqncia podemos dizer
que o tempo de CPU da nova mquina de 1,5 vezes menor que na
configurao anterior. Usando ento a Lei de Amdahl, temos:
Speedup =
1
= 1,3
(1 0,7) + 0,7 / 1,5
ou seja, a mquina passar a ser 1,3 vezes mais veloz. Se o disco fosse
alterado por outro com a mesma melhoria de desempenho, 1,5 vezes, o
desempenho final seria apenas:
Speedup =
1
= 1,1
(1 0,3) + 0,3 / 1,5
1,1 vezes mais rpido que o sistema anterior.

Isto deixa claro que temos de investir nas partes que mais influenciam
na velocidade do sistema. Investir em um componente que raramente
utilizado significa pouca melhoria do sistema como um todo. Da deriva a
seguinte observao: faa mais simples (e conseqentemente mais rpido) o
123
que se faz freqentemente. Esta uma grande mxima da Arquitetura de

Computadores.
Um outro aspecto que muito importante a forma de medio do CPI
de um processador. Um projetista precisa de simuladores da sua arquitetura
para gerar estatsticas de tal forma que o CPI possa ser mensurado. Outra
opo esperar que o hardware fique pronto e da medir in loco. Algumas
vezes possvel mensurar o nmero de ciclos de CPU olhando para o CPI de
uma determinada classe de instrues e sua freqncia de execuo. Neste
caso definimos:
n
Ciclos de Clock da CPU =
(CPIi x Ci)
i=1
onde CPIi o nmero de ciclos por segundo mdio para uma determinada
classe de instrues e Ci o nmero de instrues desta classe que
efetivamente executado. n o nmero de classes de instrues.
Por exemplo, no MIPS as instrues aritmticas so executadas em
mdia a 1 ciclo por instruo. Instrues de transferncia de dados entre a
memria e o processador executam a uma taxa de 2 ciclos por instruo.
Supondo que um determinado programa usa 60% de instrues aritmticas e
40% de instrues de carga, qual o nmero de ciclos de clock utilizados na
CPU para um programa com 200 instrues executadas?
Ciclos de Clock da CPU =1 x 0,6 x 200 + 2 x 0,4 x 200 = 280
portanto, o nmero de ciclos da CPU estimado em 280.
5.2 Mtricas de desempenho

No incomum encontrarmos propagandas de processadores que
prometem oferecer milhes de instrues por segundo, o que seria melhor que
outros que oferecessem menos. De fato, milhes de instrues por segundo, ou
MIPS (Millions of Instructions Per Second) uma mtrica popular para
comparamos computadores. No confunda a mtrica MIPS com o processador
MIPS.
124
Esta mtrica interessante porque um nmero de MIPS maior significa

um processador melhor, o que intuitivo, enquanto a medida de tempo
significa que quanto menor o tempo de CPU, melhor o processador.
Infelizmente a mtrica carece de alguns cuidados. Primeiro, ns no
podemos comparar mquinas com conjuntos de instrues diferentes usando
MIPS. Por que? Simplesmente porque os programas podem ser expressos de
formas diferentes o que leva a uma contagem de instrues diferentes e a taxa
de execuo das instrues no significa que uma mquina melhor que
outra, j que o nmero de instrues sofre variao.
Segundo, MIPS varia de programa para programa, por isto no pode
existir um nico nmero mgico que exprima o valor do MIPS para o
processador.
Terceiro e mais importante: o MIPS pode nos levar a condies
adversas de desempenho, ou seja, uma mquina com menor MIPS pode ser
mais rpida que outra com MIPS maior. O termo MIPS foi at elevado a uma
chacota no seu significado, onde alguns afirmam ser Meaningless Indicators
of Performance for Salesmen (indicador de desempenho sem sentido para
vendedores). Tudo por causa da possvel confuso com os resultados.
Vamos ver um exemplo. Um computador A executa 10 bilhes de
instrues, usando uma freqncia de 4Ghz e com um CPI de 1,0. Um
computador B executa 8 bilhes de instrues, usando a mesma freqncia de
A, mas com um CPI de 1,1. Qual das duas apresenta maior MIPS e qual o
mais rpido?
Tempo de Execuo = Ciclos de Clock x Perodo do Clock =
Ciclos de Clock
Freqncia
Ciclos de Clock = CPI x Nmero de Instrues

Ciclos de ClockA = 1,0 x 10 x 109
Tempo de ExecuoA =
10 x 109
= 2,5s
4 x 109
Ciclos de ClockB = 1,1 x 8 x 109

Tempo de ExecuoB
8,8 x 109
=
= 2,2s
4 x 109
125
MIPS =
Instrues
Tempo de Execuo x 106
MIPSA
10 x 109
=
2,5 x 106
MIPSA = 4.000 MIPS
MIPSB =
8 x 109
2,2 x 106
Portanto, conclumos que o computador A possui maior MIPS, mas

demora mais para executar os programas, em relao a B. Isto demonstra
como a mtrica pode atrapalhar.
Outra mtrica que pode ser vexatria MFLOPS (millions of floating
point operations per second). A idia por trs de MFLOPS a mesma do
MIPS, mas agora so consideradas apenas as instrues de ponto flutuante no
clculo. O problema com MIPS e MFLOPS que eles no levam em
considerao a organizao do computador em relao quantidade de ciclos
gastos por instruo, o que pode alterar completamente os resultados como
visto anteriormente.
5.3 A viso do software Benchmarking

A forma mais precisa de avaliar um computador em relao a outro
certamente executar um mesmo conjunto de programas em cada um deles e
verificar qual apresenta os melhores resultados em termos de tempo. Este
conjunto de aplicaes chamado de carga de trabalho, workload.
Infelizmente, este mtodo nem sempre possvel. Primeiro porque cada
usurio utiliza comumente um conjunto de aplicaes particulares e a
relao de melhor ou pior estaria restrita quele usurio. Segundo porque
quando estamos desenvolvendo um novo processador no temos todas as
A viso do software
MIPSB = 3.636 MIPS
A viso do software
126
ferramentas, como compiladores e montadores e sistemas operacionais j

prontos para gerar e pr em execuo os programas. Dentro deste contexto,
escolher trechos de cdigos ou rotinas que sejam executadas freqentemente
nos programas reais torna o trabalho de desenvolvimento e avaliao menos
rduo. Alm disto, os trechos so desenhados especificamente para medio
de desempenho e por isto podem representar mesmo a situao real.
Estes trechos de cdigo so chamados de benchmarks. Um conjunto
de benchmarks chamado de uma sute de benchmarks. Muitos benchmarks
so desenhados especificamente para medir o desempenho da CPU, sendo
excludos os trechos que utilizam entrada e sada e os que requerem
servios do sistema operacional. Este tipo de benchmark chamado de
kernel (no confunda com os kernels do sistema operacional).
Quanto mais especficas forem as aplicaes de um processador, mais
especficos podem ser os benchmarks e mais precisos sero os resultados. Em
nossos computadores de uso domstico construir uma sute de benchmarks
uma tarefa muito difcil. De qualquer forma, a mais famosa sute chamada
de SPEC CPU. Esta sute criada pela SPEC (Standard Performance
Evaluation Corporation) utilizada hoje com muito sucesso para medir o
desempenho relativo entre mquinas e entre verses com diferentes
componentes de uma determinada mquina. Seus 25 programas so divididos
em dois conjuntos, SPECint e SPECfp, para testes de computao inteira e
em ponto flutuante respectivamente.
Uma crescente demanda de processadores hoje em dia para os ditos
sistemas embarcados que realizam processamentos especficos e entregam
resultados para um sistema central. Muitos processadores so utilizados em
sistemas embarcados e as principais sutes de benchmarks para medidas de
desempenho de tais sistemas so Mediabench e MiBench.
Uma outra sute muito conhecida DSPstone. Esta sute
desenvolvida para medir o desempenho de processadores de sinais digitais,
DSPs. Os DSP normalmente so utilizados em sistemas embarcados, mas tm
aplicao restrita ao tratamento de sinais digitais, como filtro FIR, IIR,
transformada de Fourier e outros.
Escolher corretamente as sutes para fazer comparaes entre
mquinas tarefa importante para qualquer trabalho cientfico.
Outra face de um benchmark a sua carga de dados particular. Um
benchmark como cjpeg pode converter diversos formatos de arquivos de
imagens para o formato jpeg. Escolher qual o formato de entrada pode
interferir nos resultados. Assim tambm, os tamanhos dos dados de entrada
devem estar padronizados para que uma comparao seja ilibada.
5.4 Concluses
Aprendemos neste captulo como calcular o desempenho de uma
mquina em particular e vimos que o tempo de execuo a mtrica mais
acurada para apresentar vantagens de um computador sobre outro. Vimos que
nem sempre outras mtricas nos levam a resultados justos sobre o melhor
computador.
Aprendemos tambm que alterar uma parte do sistema pode nos levar a
melhorias pequenas de desempenho. Especificamente, aprendemos a lei de
Amdahl, que pode ser extrapolada, com restries, para qualquer assunto de
nossas vidas. O grande colorrio : faa o caso comum eficiente.
Naturalmente que o estado da arte exige um pouco mais. Os detalhes no
podem ser dispensados, mas sabemos que o esforo com eles no ir alterar
substancialmente o desempenho geral.

Este um captulo sui-generis em termos de simulao. O principal
argumento que podemos extrair da prtica com simuladores a quantidade de
ciclos por instruo para uma determinada aplicao. Mesmo assim, o fato de
conhecer os benchmarks e oper-los pode ser muito til.
Uma tarefa que comumente encontramos usando benchmarks
descobrir os hot-spots dos programas, ou seja, aquelas regies que so
utilizadas com muita freqncia. Isto muito til para que otimizaes
especficas possam ser realizadas nos cdigos. Para isto utilizamos traces de
referncias memria. Estes traces contm todos os endereos que foram
utilizados pelo programa, indicando quais os caminhos percorridos. Assim
podemos encontrar quais pontos foram mais acessados, onde se encontram os
laos mais importantes do programa etc. Estes traces tambm servem para
medir o desempenho do sistema de memrias. Veremos no captulo seguinte
como este sistema se comporta e seus benefcios.
5.6 Exerccios
5.1
5.2
Pesquise na web e produza um resumo sobre os programas que

compem a sute CPU SPECint.
compem a sute CPU SPECfp.
127
128
5.3
5.4
5.5
5.6
5.7
5.8
5.9

compem a sute MiBench.
compem a sute Mediabench.
compem a sute DSPstone.
Digamos que um sistema passe 70% de seu tempo executando
instrues na CPU e 30% de seu tempo esperando pelo disco. Um
vendedor oferece um novo processador que 50% mais rpido e custa
R$ 10.000,00. Um outro vendedor apresenta-lhe um novo sistema de
discos, duas vezes e meio mais rpido com custo de R$7.000,00. Voc
dispe de recursos para apenas um investimento, qual dos dois lhe
proporcionar melhores resultados com menor custo?
Agora voc dispe de recursos para realizar ambos os investimentos da
questo anterior. Qual a melhoria de desempenho final do seu sistema?
Considere um computador com trs classes de instrues, A, B e C,
cujos CPIs de cada classe so 1, 2 e 3 respectivamente. Agora vamos
testar dois compiladores que geram cdigo para um determinado
programa em HLL e encontramos que o primeiro gera 5 bilhes de
instrues da classe A, e 1 bilho de instrues para cada classe
restante. O segundo compilador gera 10 bilhes de instrues da classe
A e 1 bilho de instrues para cada classe restante. Assuma que todas
as instrues geradas pelos compiladores so executadas nestas
mesmas propores e que a freqncia de operao do processador
de 4Ghz. Qual compilador tem o melhor desempenho segundo o tempo
de execuo? E segundo o MIPS?
Em que situao a mtrica MIPS pode ser empregada para comparar
mquinas de forma inequvoca?
Captulo 6
Sistema de
Memrias
6.1 Introduo
A maioria das mquinas atuais utiliza a arquitetura de Von Neumann
como molde. Isto implica na adoo de um modelo fortemente baseado em
memria, onde dados e instrues so alocados em um repositrio nico. De
fato, a memria pode ser vista como um vetor onde cada posio (ndice)
contm uma instruo/dado, iniciando do endereo zero at o mximo valor de
endereamento do processador. Esta organizao de uma memria
puramente lgica do ponto de vista de sua materializao. Desde os anos 60 j
fora percebido que a materializao do conceito de memria, como descrita
acima, exigiria uma enorme quantidade de recursos. Memrias grandes e
rpidas, abstendo-se da discusso filosfica-temporal dos adjetivos, so caras
e ocupam muito espao fsico para sua implementao. Por isto, usamos hoje
um sistema de memrias formando uma hierarquia. Memrias mais rpidas,
antes denominadas escravas [6.1], agora integram praticamente qualquer
sistema de computao. Maurice Wilkes cunhou o termo em 1965, mas foi a
IBM que em 1968 introduziu no 360/85 uma memria cache, como so
conhecidas hoje as memrias escravas.
Se voltarmos nossa analogia inicial sobre o sistema de computao,
vamos perceber que temos dentro da cozinha uma pequena despensa onde
podemos guardar os ingredientes das nossas guloseimas. Certamente s faz
sentido guardar nela os ingredientes mais comumente utilizados. Quando
precisamos utilizar um ingrediente que no est em nossa prateleira, podemos
verificar se est disponvel no supermercado, mas isto requer mais tempo e
mais recursos, j que temos de sair da cozinha, ir at o supermercado,
encontrar a prateleira onde est o produto, peg-lo, pag-lo e traz-lo para
casa. S ento o ingrediente estar em nossa despensa pronto para ser
utilizado. Se o produto no estiver no supermercado preciso solicitar a um
129
130
distribuidor, que est ainda mais distante. Neste caso, preciso esperar ainda
mais e os custos envolvidos so ainda maiores. Ora, impensvel termos em
nossas casas um grande silo para depositar todos os ingredientes possveis.
Isto seria caro e ocuparia uma enorme rea. Tambm no supermercado,
impossvel armazenar todo e qualquer tipo de produto. A soluo uma
hierarquia! Agora podemos perceber que o sistema de memria exatamente
anlogo.
Formalizando os conceitos, uma hierarquia tpica de memria comea
com um mdulo rpido, pequeno e caro chamado cache, seguido por uma
memria mais lenta, maior e mais barata chamada memria principal. Estas
memrias so construdas de materiais semicondutores (tipicamente
transistores CMOS). As memrias em semicondutores so seguidas, dentro da
hierarquia, por memrias ainda maiores, mais lentas e baratas, que so
implementadas em material magntico (os discos rgidos Hard Disk, HD
so um exemplo deste tipo de memria). Este nvel da hierarquia chamado
de memria secundria ou de massa. Existe ainda um outro nvel classificado
como memria terciria, tambm em material ferromagntico, que so as fitas.
Estas so consideradas memria terciria.
O objetivo de criar uma hierarquia de memria criar uma iluso para o
programador de que ele pode acessar uma grande memria com uma enorme
velocidade. A caracterizao de uma hierarquia pode ser feita por inmeros
parmetros, dentre eles: capacidade, tempo de ciclo, latncia, penalidade por
falha/falta (miss penalty), largura de banda (bandwidth) e custo. A capacidade
de um mdulo de memria medida em bytes e seus mltiplos (Kilo, Mega,
Giga, Tera etc.). O tempo de ciclo o tempo decorrido desde o incio de uma
leitura at a memria estar pronta para uma nova leitura. A latncia o tempo
desde o incio de uma leitura at o dado estar disponvel para o usurio. A
penalidade por falha/falta o tempo, normalmente expresso em ciclos de
relgio, que leva para o dado/instruo que no est presente em um
determinado nvel da hierarquia ser recuperado do nvel inferior. A largura de
banda prov uma medida da quantidade de bits que podem ser acessados por
segundo. Finalmente, o custo o valor a ser pago por (giga) bytes de
memria. A ilustrao tpica de uma hierarquia pode ser vista na Figura 6.1.
Veja que o banco de registradores tambm pode ser considerado como parte
desta hierarquia. Os tempos de acesso so sazonais, ou seja, dependendo da
tecnologia eles podem ser outros, mas guardando uma certa proporo entre as
camadas.
131
Captulo 6: Sistema de Memrias
$$$$$
Tempo de Acesso
1ns a 2ns
Registrador
3ns a 10ns
Cache
30ns a 90ns
L1
L2
Custo
Memria Principal
5ms a 20ms
Disco Rgido
10s a 3m
Fita Magntica
Capacidade
Figura 6.1: Tpica hierarquia de memrias
Podemos ainda classificar as memrias como voltil ou no voltil.

Uma memria dita voltil quando cessada a sua alimentao ela perde todos
os seus dados. As memrias cache e principal em sua maior parte so volteis.
Memrias no volteis so aquelas que mesmo estando desligadas guardam os
dados integralmente. Os discos rgidos e as fitas so considerados memrias
no volteis. Existe um tipo de memria em silcio que tambm pode ser
considerada no voltil: a memria ROM. ROM significa memria para
leitura apenas (Read Only Memory). Este tipo de memria costuma guardar
informaes importantes sobre o sistema como a seqncia de inicializao
dos dispositivos (boot). Existe uma flexibilizao ao conceito de memria
ROM que uma memria que se pode regravar, chamada EPROM. De fato
ela costuma ser gravada uma nica vez, mas possvel apagar o seu contedo
e reprogram-la. Da o seu nome: Memria ROM apagvel e programvel
(Erasable, Programmable ROM).
Uma outra forma de classificar as memrias diz respeito recuperao
dos dados nelas armazenados. Uma memria pode ser RAM ou seqencial. A
memria RAM (Radom Access Memory) acessa qualquer dado em um tempo
fixo, ou seja, se a latncia da memria de 30ns, qualquer que seja o endereo
do dado solicitado ela vai levar 30ns para entrega do valor. As memria de
acesso seqencial, por outro lado, no possuem uma latncia fixa, pois para
acessar o dado no endereo 300 ela precisa percorrer desde o ltimo endereo
solicitado at o endereo 300. Por exemplo, para mudar de um endereo para
outro adjacente, uma memria de acesso seqencial precisa de 100ns e para
132
entregar o dado ao solicitante ela requer 15ns. Considerando que dois dados
so solicitados a esta memria, o primeiro no endereo 10 e o segundo no
endereo 25, qual o tempo desde o primeiro acesso para que o segundo dado
esteja disponvel? Bem, depois do primeiro acesso preciso percorrer 15
endereos at chegar ao endereo solicitado o que leva 1500ns e mais 15ns
para entregar o dado, totalizando 1515ns para o segundo dado ser entregue ao
solicitante. As memrias principais e cache (e tambm os registradores) so
memrias RAM, enquanto as fitas so memrias de acesso seqencial.
A diferena de velocidades encontrada entre as memrias cache e
principal fruto da tecnologia empregada em sua construo. Memrias cache
so implementadas com tecnologia SRAM (Static RAM) enquanto a
tecnologia DRAM (Dynamic RAM) usada para memrias principais.
Memrias DRAM precisam de um circuito especial para manter os dados
armazenados. Este circuito chamado de circuito de refrescamento. Ele fica
de tempos em tempos lendo os dados e re-gravando-os em suas posies
corretas. Isto torna a memria DRAM mais lenta, mas o custo do
armazenamento bem menor que o custo de uma memria SRAM.
Voltando agora ao tema da hierarquia de memria, a questo que deve
ser levada em considerao a seguinte: Quais os dados/instrues que devem
ser selecionados para os nveis mais altos da hierarquia? A resposta a esta
questo depende do comportamento dos acessos a dados e cdigos de um
programa. Tipicamente usamos dados e/ou instrues que se encontram juntos
ou prximos dentro da memria e tambm tendemos a usar dados e/ou
instrues que usamos recentemente. Esta observao define o princpio da
localidade de referncias, sobre o qual as hierarquias de memrias so
construdas com fins de otimizar o desempenho do sistema. Se a maior parte
dos dados/instrues esto presentes na poro de memria mais rpida ento,
o acesso aos dados/cdigos ser mais rpido e por isto selecionar bem estes
dados e instrues fundamental. Os nveis mais altos da hierarquia, a saber:
a memria principal e a cache (e, por conseguinte, o banco de registradores)
armazenam dados e instrues temporrias para uso o mais imediato possvel
pelo processador, ento, de fato, elas no armazenam dados perenes, mas
fazem cpias dos dados/instrues contidos no sistema de discos/fitas para
serem utilizados mais imediatamente.
Na prtica, os processadores tendem a acessar a memria de forma
muito repetitiva. Por exemplo: o valor do registrador PC sempre
incrementado de 4 unidades, assim a prxima instruo a ser executada
sempre a seguinte na memria. Isto implica que j sabemos qual o conjunto de
instrues vai ser utilizado dentro de um certo intervalo de tempo.
Naturalmente, instrues de desvio interferem nesta seqncia de execuo
das instrues, mas considerando que tipicamente temos uma instruo de

desvio a cada 5 instrues (que no saltam) interessante percebermos que a
probabilidade de virmos a utilizar uma instruo vizinha da sua antecessora na
memria muito alta. Este o princpio da localidade espacial, que diz que a
probabilidade de acessarmos instrues vizinhas muito alta. O princpio da
localidade espacial tambm usado para dados, por exemplo, quando fazemos
algum processamento sobre um vetor.
Um outro tipo de localidade de referncia a localidade temporal, que
diz que itens acessados recentemente tendem a ser acessados novamente em
um futuro muito prximo. Isto deriva do fato de que ao programarmos ns
tendemos a realizar operaes com um pequeno conjunto de variveis por vez.
Isto faz com que utilizemos as mesmas posies de memria repetidas vezes.
Tambm, a presena de laos (loops) na programao faz com que instrues
sejam executadas repetidamente.
O princpio da localidade prov a oportunidade para o sistema usar uma
pequena poro de memria rpida para efetivamente acelerar a maioria dos
acessos memria. Tipicamente apenas uma pequena poro do espao
inteiro de memria usada por vez e esta poro costuma ser acessada
freqentemente. Assim, podemos escolher esta poro para ser transferida
para uma regio alta na hierarquia de memrias, onde o acesso mais rpido.
Isto resulta em um sistema de memria que pode armazenar uma grande
poro de informaes em uma memria de baixo custo e ainda prov quase a
mesma velocidade de acesso a estas informaes como se fosse utilizada uma
enorme e cara memria rpida.
A seqncia de eventos que ocorre quando o processador pede um
dado/instruo ao sistema de memrias o seguinte: primeiro ele procura na
cache. Se a informao estiver presente a cache devolve a informao para o
processador. Isto chamado de acerto na cache (hit). Se a informao no est
na cache buscada na memria principal e uma falha na cache computada
(miss). Se o dado estiver disponvel na memria principal ele entregue
cache que o entrega ao processador. Para melhor aproveitar o princpio da
localidade espacial, no apenas a informao solicitada copiada da memria
principal para memria cache, mas um bloco inteiro de informaes
repassado. O tamanho deste bloco ser discutido brevemente. Se a informao
no est presente na memria principal, ento dizemos que ocorreu uma falta
de pgina (page fault) e a informao deve ser buscada no disco, e assim
sucessivamente.
A probabilidade de um acerto na cache (hcache) chamada de taxa de
acerto da cache e o seu complemento a taxa de falha na cache (1- hcache).
Tipicamente uma cache projetada para ter uma taxa de acerto prxima a
133
134
95%, ou seja, em 95% dos acessos, as informaes buscadas esto na cache.

Naturalmente estes so nmeros puramente estatsticos. Muitos programas
mal comportados podem apresentar estatsticas muito ruins para uma
determinada cache e assim subutilizar os recursos computacionais.
Perceba que pusemos de fora desta abordagem a questo dos
registradores. O banco de registradores, apesar de ser considerado parte
integrante da hierarquia, controlado pelo programa, ento cabe ao
programador escolher que informaes devem ser transferidas para o banco de
registradores em um determinado momento.
6.2 Memrias Cache

Em 1965 Maurice Wilkes distinguiu dois tipos de memria principais: a
primeira, convencional e a segunda, uma memria escrava, rpida e pequena,
para armazenar apenas as informaes mais freqentemente utilizadas pelos
programas. Assim nasceu a memria cache, que uma regio para guardar
informaes mais freqentemente acessadas pelo processador. A escolha das
informaes a serem duplicadas (copiadas) da memria principal na cache
feita pelo hardware que controla a cache e se baseia nos princpios da
localidade espacial e temporal. Atualmente encontramos caches em dois
nveis, ou seja, duas memrias caches fazendo parte da hierarquia de
memrias. Normalmente encontramos uma cache chamada L1 (nvel 1, Level
1) e L2 (nvel 2, Level 2). Conforme visto na Figura 6.1, a cache L1 est
localizada dentro do processador e a cache L2 fora do processador, na placa
me. L1 e L2 seguem os mesmos princpios da hierarquia: L1 mais rpida,
menor e mais cara de implementar que L2.
A Figura 6.2 mostra o esquema bsico de funcionamento de uma cache.
Em um dado instante de tempo a cache e a memria principal esto com as
informaes representadas em (a). O processador ento pede a informao
Info9. A cache verificada para saber se Info9 est presente. Caso afirmativo
a cache entrega Info9 para o processador. Na ilustrao, Info9 no est
presente na cache, ento preciso busc-la no nvel inferior da hierarquia, a
memria principal, e fazer uma cpia dela para dentro da cache. A cache ento
contm agora Info9 e pode entreg-la ao processador (b).
Neste ponto surgem as questes que precisamos resolver:
Como saber se um dado em particular est na cache?
Se estiver na cache, como saber em que posio da cache ele est?
Caso a cache esteja cheia, que informao deve ser retirada para ceder
espao nova?
135
Memria
Principal
Cache
Info1
Info2
Info3
Info4
Info5
Info6
Info7
Info8
Info9
Cache
Info2
Info9
Info5
Info4
Info2
Info5
Info4
(a)
(b)
Figura 6.2: Cache antes (a) e depois do acesso informao Info9 (b)
Vamos comear respondendo segunda questo. A maneira mais

prtica para saber onde uma informao da memria principal vai parar na
cache atribuir cada posio da cache um conjunto de possveis posies da
memria principal. Este mapeamento feito com base no endereo da
informao sendo solicitada. Alguns bits que compem este endereo indicam
em que posio da cache a informao deve ser buscada. No exemplo da
Figura 6.3 podemos perceber que os endereos 00002, 01002, 10002 e 11002
partilham a mesma posio na cache, assim como os endereos 00112, 01112,
10112 e 11112. Este tipo de mapeamento chamado de mapeamento direto e a
cache que implementa esta estratgia chamada de Cache Mapeada
Diretamente.
Memria Principal
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Cache
00
01
10
11
Figura 6.3: cache de mapeamento direto
136
O fato de n endereos serem mapeados para uma nica posio da cache

implica em sabermos qual dos n est em um determinado instante ocupando
um lugar. Por exemplo, na posio 00 da cache poderiam estar as informaes
contidas nos endereos 00002, 01002, 10002 ou 11002. Isto significa que
preciso identificar qual dos endereos est contido na cache. Para resolver este
problema as informaes de endereo so guardadas em uma posio
adjacente ao dado/instruo na cache. Esta posio adjacente chamada de
rtulo (tag). A Figura 6.4 mostra como fica uma memria cache de
mapeamento direto com rtulo. Alm do campo onde so armazenadas as
informaes, um campo de rtulo est mostrado. Veja que a concatenao do
valor da tag com os endereos da cache (chamados de ndices) forma o
endereo original da informao na memria principal.
Quando o processador pede ao sistema de memrias uma informao
ele simplesmente informa o endereo onde o dado se encontra na memria
principal, ento a cache desmembra este endereo, descobre qual ndice ele
contm e verifica se na posio correspondente na cache o tag o mesmo do
endereo solicitado. Se for, acontece um acerto, se no uma falha. Desta forma
respondemos a nossa primeira pergunta feita acima.
Memria Principal
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
aaaa
bbbb
cccc
dddd
eeee
ffff
gggg
hhhh
iiii
jjjj
kkkk
llll
mmmm
nnnn
oooo
pppp
Cache
tag ndice
01
00
01
10
11
informao
eeee
Figura 6.4: Cache de mapeamento direto com rtulo
Agora vamos fazer um exerccio de fixao com uma cache mapeada

diretamente. Suponha a cache mostrada na Figura 6.4 e uma seqncia de
acessos de leitura mostrada na Figura 6.5 (a). O primeiro acesso ao endereo
00002, conforme mostra a Figura 6.5 (b). O gerenciador da cache recebe o
endereo e desmembra-o em ndice e tag. O ndice formado pelos dois
137
ltimos bits do endereo (os bits mais direita) e a tag o restante dos bits do
endereo. Ora, no ndice 00 da cache no h informaes na cache, portanto
uma falha gerada e a informao buscada na memria principal. Neste caso
a informao do endereo 00002 aaaa. Junto com a informao tambm
armazenado o tag correspondente (neste caso os dois primeiros bits do
endereo, a saber: 00).
O prximo endereo a ser solicitado o 01002 (Figura 6.5 (c)). O
gerenciador da cache separa os campos do endereo (tag = 012 e ndice = 002).
Ele ento verifica que a posio da cache correspondente ao ndice 002 contm
uma informao. Ele checa, ento se os tags conferem (presente na cache, tag
= 002, solicitado pelo processador, tag = 012). Neste caso os tags diferem,
portanto a informao que est presente na cache no a mesma requerida
pelo processador. Uma nova falha anotada e o endereo correspondente
solicitado memria principal. A informao na cache , ento, atualizada
para o novo dado que veio da memria principal. Numa cache mapeada
diretamente cada dado tem um lugar especfico para alocar. Se houver outro
dado, este precisa ser removido. Assim respondemos a nossa terceira
pergunta.
O terceiro acesso ao endereo 11102 (Figura 6.5(d)). O gerenciador da
cache separa os campos do endereo (tag = 112 e ndice = 102). O ndice 102
na cache est vazio, portanto ele vai buscar a informao na memria
principal e armazena o dado e a tag na posio correspondente ao ndice 102.
O prximo acesso ao endereo 01002. O gerenciador da cache faz a
separao dos campos (tag = 012, ndice = 002). No ndice correspondente na
cache 002, existe uma informao. Os tags so ento comparados (tag na
cache = 012, tag solicitado = 012). Neste caso, os tags presente na cache e
solicitado so iguais, ento acontece um acerto na cache. O dado (eeee)
imediatamente repassado ao processador.
A Figura 6.5 (f) mostra o resultado final das operaes de leitura na
cache. Fica como exerccio o preenchimento da cache em cada tempo (acesso)
envolvido nesta seqncia de acessos.
(a)
Tempo
Leitura(L)
Escrita (E)
Endereo
(binrio)
1
2
3
4
5
6
7
8
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Cache (ndice)
Hit
Miss
00
01
10
11
tag/dado
tag/dado
tag/dado
tag/dado
Figura 6.5: Exemplo de acessos a uma cache
138
Leitura(L)
Escrita (E)
Endereo
(binrio)
1
2
3
4
5
6
7
8
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Tempo
Leitura(L)
Escrita (E)
Endereo
(binrio)
1
2
3
4
5
6
7
8
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Tempo
Leitura(L)
Escrita (E)
Endereo
(binrio)
1
2
3
4
5
6
7
8
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Tempo
Leitura(L)
Escrita (E)
Endereo
(binrio)
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Tempo
(b)
(c)
(d)
(e)
1
2
3
4
5
6
7
8
Cache (ndice)
Hit
Miss
00
01
10
11
tag/dado
tag/dado
tag/dado
tag/dado
00/aaaa
Miss
00
01
10
11
tag/dado
tag/dado
tag/dado
X
X
tag/dado
00/aaaa
01/eeee
Miss
00
01
10
11
tag/dado
tag/dado
tag/dado
X
X
X
tag/dado
00/aaaa
01/eeee
01/eeee
Miss
00
01
10
11
tag/dado
tag/dado
tag/dado
X
X
X
tag/dado
00/aaaa
01/eeee
01/eeee
01/eeee
Cache (ndice)
Hit
Cache (ndice)
Hit
11/nnnn
Cache (ndice)
Hit
11/nnnn
11/nnnn
139
Tempo
(f)
1
2
3
4
5
6
7
8
Leitura(L)
Escrita (E)
Endereo
(binrio)
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Cache (ndice)
Hit
Miss
X
X
X
X
X
X
X
X
00
01
10
11
tag/dado
00/aaaa
01/eeee
01/eeee
01/eeee
01/eeee
01/eeee
01/eeee
01/eeee
tag/dado
tag/dado
tag/dado
11/nnnn
11/nnnn
11/nnnn
11/nnnn
11/nnnn
11/nnnn
00/dddd
00/dddd
00/dddd
00/dddd
O segredo do acesso cache o correto particionamento dos bits de

endereos nos respectivos campos. Nosso exemplo acima puramente
hipottico, mas didtico. Vamos agora analisar um exemplo real de cache
mapeada diretamente. Suponha o processador MIPS que estamos trabalhando.
Os endereos de memria so representados com 32 bits, bem como os dados
que estamos trabalhando, que tambm so de 32 bits. Neste caso, uma
memria cache mapeada diretamente que contenha 1024 palavras de 32 bits
(capacidade = 1024 x 4 bytes = 4kbytes) utiliza os seguintes campos: os dois
ltimos bits (mais direita) so usados para selecionar um dos 4 bytes que
compem o conjunto de 32 bits dos dados. Como existem 1024 posies na
cache so necessrios 10 bits para acessar cada uma das posies (210 = 1024).
Os 20 bits restantes fazem parte do campo tag. Vamos temporariamente
desprezar os dois ltimos bits de nosso endereo, no sentido de que eles sero
mantidos iguais a 002 indefinidamente.
A Figura 6.6 mostra a diviso dos campos do endereo e o diagrama da
memria cache mapeada diretamente. Observe que os endereos que ns
temos utilizado em programao assembly so sempre mltiplos de 4 portanto
os dois ltimos bits so sempre iguais a 002. Mencionamos tambm que a
capacidade de armazenamento desta memria cache em particular de
4Kbytes. Nesta conta no estamos incluindo os bits que fazem parte do campo
de tag. Eles esto presentes e no so desprezveis, mas, por conveno, a
capacidade de uma cache medida apenas pela quantidade de bytes de
informao que ela pode armazenar.
140
Informao
requisitada
Endereo
Acerto (Hit)
31 30 ......................... 12 11...... 2
20 bits
1 0
10 bits
informao
tag
0
...
...
...
1022
1023
ndice
=
Figura 6.6: Memria cache para o MIPS
No exemplo da Figura 6.5 um pequeno detalhe foi omitido: como saber

se uma informao vlida na cache. Naquele momento tratamos
exclusivamente de dizer que a cache estava vazia em alguma de suas posies.
De fato uma cache possui associado a cada linha um bit chamado de bit de
validade (v). Ele sinaliza se uma informao na cache est coerente com o que
existe na memria principal. A coerncia na cache significa que a h uma
cpia fiel da informao na memria principal armazenada na cache.
A presena deste bit de validade muito importante na inicializao de
uma cache. Inicialmente todas as informaes na cache so consideradas
invlidas, ou seja, os valores dos tags armazenados na cache no tm
significncia para o processamento das informaes. Quando um bit de
validade vale 12 significa que a informao que est na cache coerente
com o resto da hierarquia e quando este bit vale 02 a informao est
incoerente. Todos os bits de validade so ento inicializados com 02.
medida em que so transferidas informaes da memria principal para cache,
o bit de validade correspondente passa a valer 12.
A Figura 6.7 mostra a organizao de uma cache mapeada diretamente
contendo um bit de validade associado a cada endereo de cache. Agora, um
141
acerto na cache depende tambm do bit de validade estar setado (12). Assim,
quando uma cache est vazia e, por conseguinte, todos os bits de validade
ressetados (02), qualquer tentativa de transferncia de dados da memria
principal para cache ir resultar em uma falha. medida que os dados so
copiados da memria principal para a cache, o bit de validade vai sendo
setado, o que possibilita um acerto na cache.
Acerto (Hit)
31 30 ......................... 12 11...... 2
20 bits
Informao
requisitada
Endereo
1 0
10 bits
informao
tag
0
...
...
...
1022
1023
ndice
=
Figura 6.7: Memria cache para o MIPS com bit de validade
Vamos refazer o exemplo da Figura 6.5 agora contendo um bit de

validade. A Figura 6.8 mostra a seqncia de acessos. Observe que
inicialmente (Tempo = 0) todos os bits de validade esto ressetados e por isto
no importa o que h em tag/dado. Quando o primeiro acesso realizado o
dado aaaa do endereo 00002 trazido da memria principal para cache e por
isto o dado no ndice 002 da cache uma cpia fiel do que existe na memria
principal e, por conseguinte o bit de validade setado.
142
Tempo
0
1
2
3
4
5
6
7
8
Leitura (L)
Escrita (E)
Endereo
(binrio)
L
L
L
L
L
L
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Cache (ndice)
Hit
Miss
X
X
X
X
X
X
X
X
00
01
10
11
v/tag/dado
0/--/---1/00/aaaa
1/01/eeee
1/01/eeee
1/01/eeee
1/01/eeee
1/01/eeee
1/01/eeee
1/01/eeee
v/tag/dado
0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/----
v/tag/dado
0/--/---0/--/---0/--/---1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
v/tag/dado
0/--/---0/--/---0/--/---0/--/---0/--/---1/00/dddd
1/00/dddd
1/00/dddd
1/00/dddd
Figura 6.8: Exemplo de acessos a uma cache com bit de validade
At o presente momento no tratamos a questo da escrita na cache.

Perceba que todos os exemplos propostos apenas lidam com a leitura de
informaes. Para ler um dado o processador informa o endereo do mesmo,
no barramento de endereos e emite um sinal de leitura de dados, no
barramento de controle. O dado retirado do sistema de memrias
disponibilizado ao processador pelo barramento de dados. Quando o
processador enseja escrever um dado na memria, ele disponibiliza o dado que
deseja escrever no barramento de dados e envia um sinal de escrita para o
sistema de memria, via barramento de controle, indicando uma escrita de
dados.
O comportamento do sistema de memrias para uma escrita de dados
o seguinte: uma vez requisitada pelo processador a cache verifica se o
endereo do dado a ser escrito est presente na cache. Se o dado est na cache
(acerto) o gerenciador da cache precisa tomar uma deciso: escrever o novo
dado na cache e na memria principal ou escrever o novo dado apenas na
cache.
No primeiro caso o dado a ser escrito sempre manter a consistncia
com o que existe na memria principal dado que a escrita se d
simultaneamente nas duas memrias. Esta poltica chamada de writethrough. Uma desvantagem bvia deste modelo que todas as escritas
precisam acessar a memria principal, minimizando assim o efeito benfico
(desempenho) promovido pela presena da cache. Se todos os acessos ao
sistema de memria forem de escrita ento a velocidade da hierarquia estar
limitada pela velocidade da memria principal (desconsiderando os outros
nveis da hierarquia).
Uma alternativa a este modelo escrever o dado novo apenas na cache,
na expectativa deste dado ser acessado novamente em breve. Esta poltica
conhecida como write-back ou copy-back. Neste caso haver uma
inconsistncia entre a informao na cache e na memria principal. O bit de
validade pode ajudar a resolver este problema. Ele seria ressetado sempre que
houvesse uma escrita na cache. Numa cache write-back, os dados seriam
escritos na memria principal apenas durante uma troca (substituio) de
dados em uma determinada posio. Um dado invlido precisaria ser escrito
na memria principal sempre que um novo dado fosse ocupar sua posio. Isto
acabaria com os acessos memria principal a cada acesso de escrita na
cache, por outro lado o mecanismo de acerto e erro precisaria ser re-projetado,
bem como o bit de validade sozinho no permitiria identificar se a posio da
cache est vazia, ou se foi vtima de uma escrita.
Felizmente, em aplicaes reais, o nmero de acessos memria, para
escrita de dados, muito inferior que o nmero de acessos para leitura de
dados, minimizando o impacto da adoo da poltica write-through, mais
simples, mas que pode apresentar piores resultados em termos de desempenho.
No caso de uma tentativa de escrita na cache onde o dado no est na
cache possvel escrev-lo somente na memria principal, poltica write noallocate, ou escrev-lo na memria principal e traz-lo para cache, poltica
write allocate. Caches write allocate so normalmente associadas com a
poltica write-back, enquanto write no-allocate normalmente associada com
a poltica write-through.
Vamos experimentar alterar o exemplo da Figura 6.8 usando agora uma
cache com polticas write no-allocate e write-through. A Figura 6.9 mostra as
alteraes propostas. No instante Tempo = 2 o processador solicita uma escrita
no endereo 00102 do dado zzzz. A cache informa uma falha. Como a poltica
write no-allocate, a informao imediatamente repassada para memria
principal. Nada registrado na cache, mas a memria principal passa a
aguardar o dado zzzz no endereo 00102. Perceba que no instante Tempo = 4
este dado copiado da memria para a cache. No instante Tempo = 6 o
processador escreve outro dado (yyyy) no mesmo endereo 00102. Neste
momento existe um dado na cache que vale zzzz ocupando o endereo
correspondente. H um acerto na cache e como a poltica de write-through o
novo dado escrito na cache e na memria principal ao mesmo tempo
mantendo a coerncia da cache.
Agora procure refazer este exemplo utilizando outras polticas, como
exerccio de fixao, e compare a quantidade de acertos e erros. Informe qual
seria a melhor cache para esta seqncia de acessos.
143
144
Tempo
0
1
2
3
4
5
6
7
8
Leitura (L)
Escrita (E)
[dado]
Endereo
(binrio)
L
E [zzzz]
L
L
L
E [yyyy]
L
L
0000
0100
1110
0100
0011
0100
1101
0011
Cache (ndice)
Hit
Miss
X
X
X
X
X
X
X
X
00
01
10
11
v/tag/dado
0/--/---1/00/aaaa
1/00/aaaa
1/00/aaaa
1/01/zzzz
1/01/ zzzz
1/01/ yyyy
1/01/ yyyy
1/01/ yyyy
v/tag/dado
0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/---0/--/----
v/tag/dado
0/--/---0/--/---0/--/---1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
1/11/nnnn
v/tag/dado
0/--/---0/--/---0/--/---0/--/---0/--/---1/00/dddd
1/00/dddd
1/00/dddd
1/00/dddd
Figura 6.9: Exemplo de acessos de leitura e escrita a uma cache
6.2.1 Explorando a localidade espacial

As cache apresentadas at o momento no exploram a caracterstica de
localidades espacial de referncias. Relembrando, a localidade espacial diz
que provvel que um dado/instruo vizinha na memria a outro
dado/instruo seja utilizado brevemente. Ento, ao invs de trazer da
memria principal apenas uma informao por vez, poderamos trazer um
conjunto de informaes. A cache agora precisa ter espao para alocar mais
dados por linha. A Figura 6.10 mostra a organizao de uma cache contendo 4
informaes de 4 bytes em cada linha. Chamamos de bloco uma linha da
cache. Cada bloco da cache proposta na figura possui 16 bytes. Para selecionar
a informao que efetivamente ser entregue ao processador utilizamos um
MUX cujas linhas de seleo so retiradas do endereo solicitado. Para uma
cache com 4 informaes (tambm chamadas de palavras) por bloco
precisamos de 2 bits para selecion-las. A capacidade de armazenamento desta
cache de 1024x16 = 16Kbytes. Perceba que existe um nico bit de validade
para um bloco inteiro. Cada transferncia da memria principal para cache
aporta 4 palavras, bem como, no caso de uma poltica write back, um bloco
inteiro transferido da cache para memria principal no caso de uma
reposio de algum bloco invlido.
Vamos fazer um exemplo simples para fixarmos as idias sobre as
caches com mltiplas palavras por bloco. Em uma cache mapeada diretamente
com 64kbytes e 8bytes por bloco, quais os campos de endereo so usados
para ndice, tag e escolha da palavra do bloco? Considere a palavra sendo
indivisvel e de 32bits.
A resposta para esta questo a seguinte: como temos blocos de 8
bytes, temos, de fato, duas palavras por bloco, ento precisamos de apenas 1
bit para selecionar a palavra no bloco. Desprezando os bits 0 e 1 do endereo,
o bit para selecionar a palavra ser o bit de nmero 2. Como a memria de
145
64kbytes e temos 8 bytes por bloco, existem 64x1024/8 blocos, ou seja, 8192
blocos. Portanto so necessrios 13 bits para selecionar o bloco, pois
log2 8192 = 13. Estes bits sero ento de 3 a 15 no endereo. Tudo que resta
vai para a comparao dos tags. Os bits de 16 a 31 formam o campo da tag.
Endereo
Acerto (Hit)
18 bits
Informao
Solicitada
31 30 ..................14 13 ...........4...3. 2 1 0
tag
2 bits
informaes
10 bits
0
...
1
...
1022
...
...
...
...
1023
ndice
MUX
Figura 6.10: Memria cache para o MIPS com blocos de 16 bytes
Vamos ver um exemplo de como podemos localizar uma informao

em uma cache mapeada diretamente. Para isto vamos analisar a seguinte
configurao: capacidade de 128bytes e 4 palavras/linha. Neste caso, como
existem 16 bytes por linha e a capacidade de 128bytes, ento existem
128/16=8 linhas. Para enderear 8 linhas preciso utilizar 3 bits e para
enderear 4 palavras preciso utilizar 2 bits, portando o endereo enviado ao
processador ser dividido em 25 bits de tag, 3 de ndice de linha e 2 de seleo
da palavra. Os dois bits menos significativos sero descartados.
A Figura 6.11 mostra como um endereo 00400abch ser enxergado
pela cache. Os bits 3 e 2 formam o seletor de palavras, como valor 112. Os bits
6, 5 e 4 formam o ndice da linha, com valor 0112. Os bits restantes, 31 a 7,
formam a tag, cujo valor ser 00000000010000000000101012 (0008015h).
Um fato importante para o mapeamento seguir um padro que um endereo
como este, quando provoca uma falha na cache, faz com que os seus trs
antecessores na memria principal sejam trazidos para a cache. Se o endereo
fosse 00400ab8h, os dois antecessores e o sucessor seriam trazidos juntos para
a cache.
146
Endereo
Acerto (Hit)
...
1 0 1 1 11 0 0
25 bits
Informao
Solicitada
31 30 .......................... 7 6 5 4 3 2 1 0
tag
3 bits
2 bits
00
01
10
11
000
001
010
011
100
101
110
111
ndice
informaes
=
MUX
Figura 6.11: Localizao de uma informao na cache
6.2.2 Memrias cache associativas por conjuntos

Nestas cache que apresentamos at o presente momento existe um
limite para explorao da localidade temporal. Isto porque cada endereo na
memria principal ocupa um lugar pr-determinado na cache. Uma
possibilidade mais amena seria permitir que uma posio da memria
principal pudesse ocupar uma dentre m posies na cache. As cache
associativas por conjunto (set associative) replicam seus campos de
informaes e tags e permitem que uma informao da memria principal
possa ocupar mais de uma posio.
Um esquema de uma cache associativa por conjunto pode ser vista na
Figura 6.12. Esta cache permite que cada informao da memria principal
possa ficar entre o primeiro plano (way 0) ou o segundo plano (way 1) de
dados da cache. Uma cache deste tipo conhecida como cache associativa por
conjuntos de 2 caminhos (2-way set associative). Isto significa que um
determinado dado pode ocupar 1 entre 2 possveis lugares. Uma cache 4-way
set associative permite que um dado ocupe 1 entre 4 possveis posies. Na
Figura podemos observar uma rplica dos circuitos que so usados para
comparao, acerto (hit) e escolha da palavra do bloco. Um acerto na cache
agora pode acontecer em qualquer dos planos. Isto implica que o acerto pode
147
vir do plano 0 ou do plano 1. ainda preciso selecionar dentre as palavras

disponveis na sada dos muxes qual deve ser entregue ao processador. Para
isto usado um codificador 2nn, onde o nmero de planos vale log2 n. Os
hits de cada plano so ligados ao codificador e dele sai um sinal de um novo
mux para selecionar a palavra correta a ser entregue ao processador.
A cache mostrada na Figura 6.12 possui 1024 conjuntos, que so
apontados pelo campo ndice do endereo. Tal cache tem capacidade de
32Kbytes.
Endereo
Acerto (Hit)
Informao
Solicitada
31 30 ..................14 13 ...........4...3. 2 1 0
2 bits
18 bits
tag
informaes
Way 1
10 bits
0
1
...
...
...
1022
...
...
...
...
...
...
...
...
1023
conjunto
MUX
MUX
codificador
2nn
Way 0
MUX
Figura 6.12: Memria cache associativa por conjuntos do MIPS
Uma cache mapeada diretamente pode ser vista como um caso

particular de uma cache associativa por conjunto, a saber, uma cache 1-way
set associative.
Em caches associativas por conjunto surge uma questo muito
particular. Uma vez preenchido um conjunto, quando for necessrio substituir
um bloco da cache, qual dos componentes do conjunto deve ceder lugar para o
novo dado? O esquema mais comum de poltica de troca de dados na cache a
Menos Recentemente Usada LRU (Least Recently Used). Nesta poltica, o
bloco a ser desprezado ser aquele que est sem uso h mais tempo. Isto
requer um controle temporal do uso de cada bloco. Por exemplo, em nossa
cache da Figura 6.13 supondo que o conjunto 1 do plano 0 foi usado no
momento Tempo = 2 e que o conjunto 1 do plano 0 foi preenchido no instante
Tempo = 5, e agora em Tempo = 9 houve uma falha na cache e um novo bloco
deve ser colocado no conjunto 1. Qual dos dois conjuntos anteriores deve ser
148
expurgado da cache? Pela poltica LRU, o bloco pertencente ao plano 0 deve

ser ceder seu lugar, pois ele foi utilizado h mais tempo.
Vamos ver um exemplo de preenchimento de uma cache associativa por
conjuntos com a seguinte configurao: Capacidade: 512bytes, 32 Conjuntos e
2 palavras/bloco. Palavras de 32 bits. O trecho da memria principal com os
respectivos dados est mostrado na Figura 6.13 (a). A seqncia de acessos a
seguinte: 40000028h, 40000000h, 40000004h, 4000000ch, 40000008h,
40000428h, 40000128h, 4000012ch, 40000128h, 4000012ch, 40000028h. Todos
os acessos so de leitura de dados.
Iniciamos desenhando o esquema da cache. Ora, possuindo a cache 32
conjuntos e 2 palavras de 32 bits (4 bytes) por bloco, ento cada plano contm
32x2x4 bytes = 256 bytes. Como a cache tem capacidade para 512bytes ento
existem 2 planos (way 0 e way 1). A Figura 6.13(b) mostra a organizao da
cache. Os planos foram colocados lado a lado para efeito de visualizao dos
dados.
Vamos agora determinar os campos que compem o endereo, como
visto pela cache. Os bits 0 e 1 so desconsiderados pois sempre fazemos
acesso a palavras de 32 bits. O bit 2 serve para selecionar a palavra dentro do
bloco que ser enviada ao processador. Para selecionar os conjuntos
precisamos de 5 bits, pois 25 = 32. Os bits de 3 a 7 so ento escolhidos. Os
bits de 8 a 31 representam o campo de tag.
O primeiro acesso ocorre ento ao endereo 40000028h. Este valor em
binrio vale 0100 0000 0000 0000 0000 0000 0010 10002. Os bits 0 e 1 so
desprezados. O bit 2 indica que a palavra a ser selecionada a 0 e os bits de 3
a 7 formam 001012 o que indica que o conjunto a ser acessado o 5. Os bits
em negrito no endereo em binrio representam o campo do conjunto. O bit
sublinhado indica o campo da escolha da palavra. Ora, neste conjunto, o bit de
validade de ambos os planos vale 0, portanto ambos indicam uma falha na
cache. Assim sendo, preciso fazer um acesso memria principal e
recuperar o dado.
Este acesso memria principal deve trazer duas palavras adjacentes.
Uma delas obrigatoriamente ser a palavra que est no endereo 40000028h,
mas a segunda palavra a ser copiada da memria pode ser a sua antecessora
(endereo 40000024h) ou sua sucessora (endereo 4000002ch). Para descobrir
isto observamos onde a informao requerida vai ser armazenada. Ora, o bit
de escolha de palavra vale 0, portanto a informao vai ser armazenada na
palavra 0. Ento o campo que nos resta preencher a palavra 1 que a
sucessora da palavra 0 na memria.
149
(a)
(b)
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
tag
40000000h
40000004h
40000008h
4000000ch
...
40000020h
40000024h
40000028h
4000002ch
...
40000120h
40000124h
40000128h
4000012ch
...
40000420h
40000424h
40000428h
4000042ch
Way 0
informaes
0a00107a h
10202398 h
00000000 h
ffffffff h
....
78ffffff h
3affff80 h
8763482f h
12650298 h
....
6abcdef7 h
020013ee h
5465387e h
ffeabc96 h
....
98273457 h
3487671a h
46462ffe h
6453f0ff h
tag
Way 1
informaes
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Figura 6.13: Exemplo de acessos a uma cache set associative
150
Uma regra prtica utilizada pelo sistema de memrias zerar o(s) bit(s)
de seleo de palavra e solicitar a memria principal, a partir deste endereo
modificado, tantas palavras quantas forem necessrias para preencher o bloco
da cache.
Finalmente temos de escolher em qual dos planos o bloco ser
armazenado. Neste instante a escolha indiferente, pois ambos os blocos que
compem o conjunto esto vazios. Vamos escolher ao acaso o plano 0. Os
dados dos endereos 40000028h e 4000002ch so copiados para cache. A
Figura 6.14 mostra como fica a cache depois de copiados os dados da
memria principal.
Observe que o tag armazenado pertence ao bloco inteiro.
v
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
tag
Way 0
informaes
palavra 0 palavra 1 conjunto v
400000 h
8763482f h
12650298 h
...
...
...
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
0
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
...
Way 1
informaes
palavra 0 palavra 1
...
...
O segundo acesso ocorre palavra no endereo 40000000h. Extraindo

os campos vamos perceber que a palavra escolhida a 0 e o conjunto onde ela
reside tambm o conjunto 0. Ora, no conjunto 0 ambos os blocos so
invlidos, ento acontece uma nova falha. Como no passo anterior os dados
dos endereos 40000000h e 40000004h sero copiados para cache. A Figura
6.15 mostra o resultado da cpia dos dados na cache.
151
v
1
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
tag
400000 h
Way 0
informaes
0a00107a h
10202398 h
400000 h
8763482f h
12650298 h
...
...
...
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
0
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
...
Way 1
informaes
palavra 0 palavra 1
...
...
O terceiro acesso feito ao endereo 40000004h. Extraindo os campos

do endereo temos: palavra selecionada = 1, conjunto = 0 e tag = 400000h.
Ora, no conjunto 0 existe um bloco vlido cuja tag vale exatamente 400000h.
Assim sendo, se caracteriza um acerto na cache. A palavra 1 do plano 0
ento entregue ao processador, conforme mostrada na Figura 6.15.
O quarto acesso feito palavra de endereo 4000000ch. Neste caso, os
campos so os seguintes: palavra selecionada = 1, conjunto = 1 e tag =
400000h. O conjunto 1 est ainda vazio, em qualquer que seja os planos, ento
uma falha assinalada. Os dados a serem retirados da memria so os de
endereos 40000008h e 4000000ch. Observe que o endereo requerido
corresponde palavra 1 na cache e portanto a cache preenchida com seu
antecessor e no o seu sucessor. A Figura 6.16(a) mostra como fica a cache
depois deste acesso.
O quinto acesso feito palavra de endereo 40000008h. Os campos
extrados de endereo so: palavra selecionada = 0, conjunto = 1 e tag =
400000h. Neste instante existe no plano 0, conjunto 1 uma tag de valor
400000h, portanto um acerto sinalizado e a palavra 0 deste plano/conjunto
disponibilizada ao processador.
O sexto acesso feito ao endereo 40000428h. Os campos associados
so: palavra selecionada = 0, conjunto = 5 e tag = 400004h. Ora, no conjunto 5
do plano 0 existe um bloco vlido, mas a tag nele armazenada vale 400000h.
Portanto um acerto no caracterizado. Veja, entretanto, que este conjunto
tem uma posio vazia no plano 1 e portanto, apesar de ser assinalada uma
152
falha na cache, no precisamos destruir o dado anteriormente armazenado.

Simplesmente colocamos os novos dados no plano 1. A Figura 6.16(b) mostra
a cache depois deste acesso.
v
1
1
0
0
0
1
0
0
0
0
0
tag
400000 h
400000 h
Way 0
informaes
0a00107a h
00000000 h
10202398 h
ffffffff h
400000 h
8763482f h
12650298 h
...
...
...
0
0
0
0
0
0
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
0
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
...
Way 1
informaes
palavra 0 palavra 1
...
...
(a)
v
1
1
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
tag
400000 h
400000 h
informaes
0a00107a h
00000000 h
10202398 h
ffffffff h
400000 h
8763482f h
12650298 h
...
...
...
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
1
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
400004 h
...
Way 1
informaes
palavra 0 palavra 1
8763482f h
12650298 h
...
(b)
...
153
Chegamos ao stimo acesso, onde a palavra solicitada est no endereo

40000128h. Os campos extrados deste endereo so: palavra selecionada = 0,
conjunto = 5 e tag = 400001h. Neste instante o conjunto 5 contm dois blocos
vlidos, entretanto, nenhum deles contm a tag 400001h. Isto caracteriza uma
falha na cache. Agora j no h espaos vazios para que um novo bloco possa
ser copiado para cache sem sacrifcios de alguns dados. Precisamos, ento,
selecionar qual bloco ser sacrificado. Aqui entra a poltica LRU. Ora o bloco
que foi utilizado h mais tempo foi o bloco contido no plano 0. Ento, este
ser escolhido para ceder seu lugar ao novo bloco. A Figura 6.17 mostra o
novo bloco copiado da memria.
v
1
1
0
0
0
1
0
0
0
0
0
tag
400000 h
400000 h
0a00107a h
00000000 h
10202398 h
ffffffff h
400001 h
5465387e h
ffeabc96 h
...
0
0
0
0
0
0
Way 0
informaes
...
...
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
1
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
400004 h
...
Way 1
informaes
palavra 0 palavra 1
8763482f h
12650298 h
...
...
O oitavo acesso ocorre palavra de endereo 4000012ch. Esta palavra

faz parte do novo bloco recm-chegado cache e, sem mais delongas,
podemos informar o acerto na cache. O mesmo ocorre para o nono e dcimo
acesso.
Finalmente ocorre o dcimo primeiro acesso. O endereo requisitado
40000028h. Neste caso os campos extrados so: palavra selecionada = 0,
conjunto = 5 e tag = 400000h. No conjunto 5 no existe um bloco vlido em
qualquer de seus planos que contenha tal tag. Assim sendo uma falha
consumada. Mais uma vez preciso escolher qual bloco pertencente a este
conjunto ser sacrificado. Ora o bloco do plano 1 foi o menos recentemente
utilizado e por isto, utilizando a poltica LRU, ele deve ser descartado.
154
A Figura 6.18 mostra o contedo da cache aps esta seqncia de

acessos. Foram computados 5 acertos em 11 acessos, uma taxa de acerto de
45%, que um valor muito baixo. Vale salientar, entretanto, que os primeiros
acessos cache costumam promover uma grande quantidade de falhas.
medida que os programas vo sendo executados, esta taxa de acerto tende a
aumentar substancialmente.
v
1
1
0
0
0
1
0
0
0
0
0
tag
400000 h
400000 h
0a00107a h
00000000 h
10202398 h
ffffffff h
400001 h
5465387e h
ffeabc96 h
...
0
0
0
0
0
0
Way 0
informaes
...
...
0
1
2
3
4
5
6
7
8
9
10
0
0
0
0
0
1
0
0
0
0
0
26
27
28
29
30
31
0
0
0
0
0
0
tag
400000 h
...
Way 1
informaes
palavra 0 palavra 1
8763482f h
12650298 h
...
...
Agora que finalizamos nosso exemplo podemos lucubrar sobre

alternativas de organizao de cache. Por exemplo, uma cache que tenha
apenas um conjunto de blocos. Neste caso o nmero de planos ser o nmero
de blocos da cache e qualquer dado pode ocupar qualquer posio na cache.
Esta cache conhecida como totalmente associativa (fully-associative). A
maior dificuldade para implementar caches fully-associatives o
gerenciamento da poltica de substituio de cache. Quanto maior o nmero de
planos, mais complexo fica determinar qual dos blocos deve ser substitudo, a
menos que nenhuma poltica seja implementada.
Para aumentar o desempenho de um sistema, usando caches preciso
projet-las para a melhor situao possvel. Veja que alguns programas podem
apresentar um comportamento no convencional, com baixa localidade
temporal e/ou espacial e isto compromete o desempenho geral do sistema.
Uma tcnica normalmente utilizada para melhorar o desempenho de

caches utilizar duas caches em paralelo. Uma para dados e outra para
cdigos (programas). Isto permite que dois acessos possam ser feitos
simultaneamente ao sistema de memrias. Outra abordagem, empregada
largamente na indstria um subsistema de caches, com vrios nveis de
memrias cache. Convencionalmente existem dois nveis L1 e L2, O primeiro
nvel est localizado dentro do prprio chip do processador e o segundo nvel
fica normalmente na placa me do sistema. A efetividade de uma cascata de
caches muito longa, com 8, 16 nveis bastante questionvel, mas entende-se
que entre 2 e 4 nveis as melhorias de desempenho podem valer o custo.
Agora que entendemos os princpios que regem a construo de
memrias cache, vamos visitar um outro nvel da hierarquia de memrias: a
memria principal. Neste nvel so implementados conceitos muito
conhecidos como memria virtual, paginao e segmentao de memria.
Ento, parte dos aspectos fsicos da memria principal, vamos conhecer e
aprender a explorar estes conceitos.
6.3 Memria Principal

J mencionamos que a memria principal implementada em sua maior
parte por mdulos volteis de memria. Isto significa que ao ligarmos um
computador esta memria estar praticamente vazia. Nossos programas esto
armazenados em memrias magnticas, tipicamente no disco rgido do
computador. A mquina no sabe quais programas sero utilizados dentro da
mirade de possibilidades e downloads que se apinham em nossa memria de
massa. Para um programa ser executado ele trazido, pelo sistema
operacional, para memria principal e ento iniciado.
A memria principal tambm tem um limite fsico de mdulos que
podem ser utilizados na placa me. Uma arquitetura tpica de 32 bits de
endereamento capaz de enderear at 232 = 4Gbytes de informaes, mas
nem sempre, ou quase nunca, esta quantidade de memria permitida em uma
placa me convencional. Memrias principais na ordem de 1Gbytes hoje j
so realidade, mas ainda estamos em um patamar tpico de 256Mbytes. Apesar
destes nmeros serem uma realidade hoje eles podem mesmo ser motivo de
chacota em breve, mas o fato de existir um limite fsico no est prximo de
seu fim. Bem, o programador tende a se abster destas restries e fazer seus
programas sem se preocupar como, nem em que lugar da memria ele ser
alocado. Vamos chamar de processo o programa que o usurio executa.
Em um sistema multi-processos (com multiprogramao) cria-se uma
certa iluso de que o processador capaz de executar diversos processos por
155
156
vez, embora, o tempo do processador seja, de fato, compartilhado entre estes

processos. parte desta discusso, o que importa que o usurio possui um
espao de memria em que diversos processos devem estar para serem
executados. A memria principal tem uma regio pr-determinada que
reservada para o Sistema Operacional e por isto o usurio precisa conviver
com um espao ainda menor da memria principal para seus processos (Figura
6.19(a)).
Agora vamos mostrar uma limitao tpica que um sistema multiprocessos est sujeito. Imagine um sistema com uma memria principal de
1Mbytes, apenas para efeito didtico. Destes, 128kbytes so reservados para o
sistema operacional. A Figura 6.19(a) mostra este espao. O usurio ento
decide usar o processo A que ento carregado na memria principal. O
processo A ocupa 350Kbytes e vai ser colocado no primeiro espao livre de
memria (Figura 6.19(b)). O mesmo ocorre com o processo B de 200kbytes e
C de 256Kbytes (Figura 6.19(c)). Neste ponto ainda restam 90kbytes livres,
mas o usurio resolve utilizar um outro processo (D) de 128Kbytes. O Sistema
Operacional precisa abrir espao na memria para este novo processo. Ele
decide ento expurgar o processo A da memria. O processo D alocado no
espao de A (Figura 6.19(d)). Um processo E, de apenas 100kbytes, tambm
chamado pelo usurio alocado (Figura 6.19(e)). O usurio ento resolve
utilizar novamente o processo A. Neste instante o processo A no est mais na
memria principal e ento ele precisa ser recuperado. O Sistema Operacional
precisa mais uma vez decidir quem retirar da memria. Ele decide retirar
ento os processos B e C que foram utilizados menos recentemente. O
processo A novamente alocado na memria (Figura 6.19(f)).
Quando um processo chamado pelo usurio posto na memria e
comea a ser executado ele guarda algumas informaes, dados entrados pelo
usurio, ento para retirar um processo da memria, sem termin-lo, preciso
guard-lo em algum lugar. Um espao no disco reservado para guardar este
processo. Chamamos de swap de disco o fato de retirarmos da memria um
processo que estava sendo executado e colocarmos de volta um outro
processo, que estava suspenso no disco, para a memria. Veja que neste
modelo os tamanhos dos processos interferem enormemente no desempenho
do sistema, bem como a inteligncia do Sistema Operacional em alocar os
espaos vazios. Veja tambm que o processo A comeou a ser executado em
uma regio da memria, mas devido ao swap de disco ele foi parar em outra
regio da memria. Isto significa que os processos no tm endereos fixos
para serem executados. Finalmente, percebemos que um processo grande,
maior que a memria presente no sistema, nunca poderia ser executado, pois
no haveria como aloc-lo.
157
1M
fffffh
Processo C
Processo C
Processo C
Espao
do usurio
Processo B
Processo B
Processo B
Processo A
Processo E
Processo E
Processo A
Processo A
Processo D
Processo D
Processo D
S.O.
S.O.
S.O.
S.O.
S.O.
S.O.
(a)
(b)
(c)
(d)
(e)
(f)
768K
Espao
do usurio
512K
256K
20000h
00000h
Figura 6.19: Alocao de memria
Todas estas limitaes apontadas levaram a um conceito de paginao

de cdigo e de memria. Cada processo ento dividido em partes, de
tamanhos fixos, chamadas de pginas. Estas partes, em geral, so pequenas e
so alocadas em regies da memria disponveis chamadas quadros (frames).
Os frames so freqentemente chamados tambm de pginas. Um processo A
pode agora ser dividido em diversas pginas e estas no necessitam ocupar
frames consecutivos. O sistema operacional precisa manter uma tabela
dizendo a quem pertence (a qual processo) cada frame e quais so os frames
livres no sistema. Tambm preciso saber onde foi alocado cada pgina do
cdigo.
Quanto aos endereos utilizados, j vimos que no podemos garantir
que um processo vai ser executado em uma determinada regio de memria,
ento, ao programarmos utilizamos endereos ditos lgicos (ou virtuais), mas
quando um processo carregado para memria, todos os saltos precisam ser
verificados e os campos de deslocamentos das instrues precisam ser
conferidos e possivelmente acertados (este procedimento chamado de
relocao ou realocao). Os endereos onde as instrues so efetivamente
executadas so chamados de endereos fsicos.
Um esquema parecido com o que ocorre com a cache usado para
particionar o endereo lgico e encontrar o endereo fsico correspondente. A
Figura 6.20 mostra o esquema convencional de traduo de endereos. Veja
que partes dos bits do endereo virtual so usadas para indicar o deslocamento
dentro de uma pgina e a poro restante usada para indicar um nmero de
158
pgina virtual. Cada pgina virtual alocada em uma pgina fsica (frame) e
ela pode estar em qualquer lugar na memria principal. No modelo da figura,
por exemplo, usamos 8 bits para o deslocamento dentro de uma pgina,
portanto as pginas tm tamanhos de 28=256 bytes. Vemos tambm que o
endereo fsico tem apenas 20 bits, ou seja, a memria fsica disponvel para
uso de apenas 220=1Mbytes. Portanto na memria inteira temos 4096 frames
de 256 bytes cada.
Para encontrar um endereo fsico correspondente a um endereo virtual
uma tabela de pginas utilizada. Esta tabela indexada por uma parte do
endereo virtual que o Nmero da Pgina Virtual. Para cada nmero de
pgina virtual possvel uma entrada na tabela de pginas utilizada. No
exemplo da Figura 6.20, cada entrada guarda o incio do endereo fsico
correspondente (os 12bits mais significativos). Um endereo virtual
00000104h seria traduzido ento como 45a04h.
Os processos tm a iluso de dispor de 4Gbytes, mas de fato eles so
executados em apenas 1Mbyte de memria real. Hoje em dia usamos pginas
entre 4kbytes e 64kbytes. O tamanho da pgina um dos principais fatores
para definir o desempenho do sistema: pginas grandes requerem tempos
grandes para sua carga na memria principal, por outro lado, mais
informaes por pgina implicam em menos necessidades de acesso ao disco.
31 30 29 28 ................................................................9 8
Endereo Virtual
Nmero da Pgina Virtual
7 6..................................3 2 1 0
deslocamento na pgina
04h
Virtual
000001h
Endereos
Fsico
45a
...
19 18 17..............................9 8
Endereo Fsico
7 6..................................3 2 1 0
Nmero da Pgina Fsica deslocamento na pgina
Figura 6.20: Mapeamento de endereos virtuais em fsicos
6.3.1 Memria Virtual

O principal conceito desta seo a memria virtual. Ele pode ser
enxergado como uma extenso do conceito de paginao. Um detalhe que
deixamos para mencionar at ento que um processo que ocupa um espao
maior que a memria fsica disponvel pode vir a ser executado. Segundo o
princpio da localidade, os programas passam a maior parte de seu tempo
executando um pequeno trecho do cdigo. Ento, de fato, no seria necessrio
carregar todas as pginas para execuo de um processo, mas apenas uma
poro delas, na esperana de serem as que mais freqentemente so
utilizadas. Uma memria organizada desta forma, paginada e com apenas um
conjunto de pginas de um processo carregado por vez, chamada de
memria virtual.
Quando um endereo virtual solicitado ao sistema de memria e este
no tem um correspondente na memria principal, dizemos que ocorreu uma
falta de pgina (page fault). Uma nova pgina deve ser ento carregada para
a memria principal.
Quando ocorre um falta de pgina, o controle passa para o Sistema
Operacional (normalmente via interrupo) que deve ento buscar a pgina
correspondente no disco rgido e decidir onde aloc-la na memria fsica. Um
endereo virtual no suficiente para indicar onde est uma pgina no disco.
Ento, quando um processo inicializado, uma regio especial no disco, page
file, criada para comportar todas as pginas do processo. Uma estrutura de
dados necessria para localizar uma pgina corretamente neste espao. Esta
estrutura de dados pode fazer parte da tabela de traduo de endereos (tabela
de pginas) ou pode ser uma estrutura auxiliar.
Uma tabela de endereos compartilhada precisa de um sinalizador que
indique se o endereo presente um endereo fsico ou um endereo de
disco. medida que algumas pginas so carregadas para memria principal,
elas vo ganhando endereos fsicos associados aos endereos virtuais. As
pginas que ficam no disco devem ter associadas a ela um endereo (no disco)
que permita ao sistema operacional realizar um swap. A Figura 6.21 mostra
um exemplo de tabela compartilhada. Para identificar se o endereo presente
na tabela um endereo de disco ou fsico usado um bit de validade. Quando
o bit de validade for 02 a pgina est no disco e quando for 12 a pgina est na
memria principal. Inicialmente todos os bits de validade so ressetados e
medida que as pginas associadas vo sendo alocadas na memria, eles vo
sendo setados.
A tabela de pginas construda em um espao reservado da memria.
Cada processo iniciado pelo usurio tem sua prpria tabela de pginas. Estas
159
160
tabelas podem ocupar um espao considervel na memria, por isto muitas

tcnicas so utilizadas para minimizar o problema. Tratar aqui destas tcnicas
no est no escopo deste livro, mas certamente um bom texto de Sistemas
Operacionais contm informaes mais aprofundadas.
O conceito de memria virtual de suma importncia para o
entendimento de Sistemas Operacionais, entretanto, nossa abordagem no vai
entrar em detalhes de funcionamento de uma implementao em particular do
conceito. Existem tcnicas muito apuradas e algoritmos muito eficientes para
lidar com falta de pgina, proteo de processos e traduo eficiente de
endereos, mas no trataremos destas solues aqui.
31 30 29 28 ................................................................9
Endereo Virtual
8 7 6..................................3 2 1 0
Nmero da Pgina Virtual
deslocamento na pgina
10ac02
v
1
...
1
0
1
...
0
1
Endereo
Fsico
...
45a
...
19 18 17.............................9 8
Disco
7 6..................................3 2 1 0
Nmero da Pgina Fsica deslocamento na pgina
Endereo no Disco
Endereo Fsico
Figura 6.21: Mapeamento de endereos virtuais em fsicos e de disco
6.4 Memrias de massa

Antes da existncia de discos de armazenamento magntico de dados,
cartes perfurados ou fitas ferro-magnticas eram as nicas formas de
armazenamento durvel de dados. No precisa dizer que este tipo de
161
armazenamento levava a perdas de dados e leitura seqencial e lenta de cada

informao desejada. Alm disto, a degradao do material mediante as
intempries era evidente. Em 1956 a IBM lanou o RAMAC, um computador
que usava um conjunto de discos magnticos para armazenamento de dados.
Nada muito portvel cada disco ocupava quase um de dimetro e o total do
conjunto pesava quase uma tonelada, mas o que pesava mesmo era o preo:
milhes de dlares.
Um disco rgido atual custa bem menos e guarda bem mais
informaes, entretanto a idia bsica se mantm. Um disco basicamente um
crculo de metal, vidro ou plstico recoberto com um material magntico
capaz de orientar suas partculas e assim formar um campo magntico tal que
quando lido pode ser interpretado como um dado binrio.
Os dados em um disco magntico so armazenados de uma forma muito
padronizada. Cada superfcie do disco dividida em circunferncias
concntricas chamadas de trilhas. Por sua vez, cada trilha dividida em arcos
de tamanhos iguais chamados de setores. Em cada setor um conjunto de dados
armazenado. Junto com eles, alguns bytes de identificao. A Figura 6.22
mostra uma organizao tpica de um disco magntico. Existe um espao entre
trilhas e um espao entre os setores. Dentro de um setor temos dois campos
principais: um cabealho, contendo a identificao do setor (nmero da trilha,
nmero da cabea de leitura, nmero do setor) e um campo de dados contendo
efetivamente os dados. Os tamanhos indicados em bytes na figura referem-se a
um disco rgido comercial. Tanto o cabealho, quanto os dados so envolvidos
em um par de campos: campo de sincronismo (SYN) e de checagem de erros
(CRC).
Trilha
Setor
Dados
Dados
512
SYN
1
SYN
1
#
Trilha
2
Cabealho (ID)
#
#
Cabea Setor
1
1
CRC
2
CRC
2
Espao entre trilhas

Espao entre setores
Figura 6.22: Organizao tpica dos dados em um disco magntico
162
Um disco magntico possui tipicamente entre 10.000 e 50.000 trilhas e

de 100 a 500 setores por trilha. Um setor tpico possui 512 bytes de dados.
Inicialmente todas as trilhas possuam o mesmo nmero de setores, mas
recentemente (desde os anos 90) h uma flexibilizao desta restrio.
6.4.1 Discos rgidos

Um disco rgido normalmente implementado com um conjunto de
discos magnticos chamados bandeja (platter), sobrepostos e com um eixo
central comum. Cada bandeja possui duas superfcies magnetizveis e
independentes. Um pente de braos mecnicos usado para posicionar as
cabeas de leitura/escrita em um determinado setor. O conjunto de trilhas
sobre as quais esto posicionadas as cabeas de escrita/leitura chamado de
cilindro. A Figura 6.23 mostra a organizao de um disco rgido. Para
proteger as bandejas de poeira, o conjunto lacrado, o que possibilita tambm
melhoria na aerodinmica do movimento das cabeas de leitura e escrita.
Os discos rgidos giram a uma velocidade constante durante o processo
de leitura ou escrita. Hoje tipicamente encontramos discos de 7.200 rpms. As
bandejas tm um dimetro tpico de 3,5 polegadas.
Para acessar os dados armazenados em um disco rgido o sistema
operacional emite uma seqncia de comandos para o hardware que controla o
disco rgido. O primeiro passo posicionar a cabea de leitura e escrita sobre
a trilha correta. O tempo que leva para este passo chamado de tempo de
busca (seek time). Depois de encontrada a trilha, preciso esperar que o disco
gire at o incio do setor desejado. Este tempo de espera chamado de atraso
rotacional (rotational delay ou rotational latency). Finalmente, a leitura dos
dados feita. O tempo gasto para esta leitura chamado de tempo de
transferncia (transfer time). O tempo de transferncia determinado pela
velocidade de rotao, tamanho do setor e nmero de bytes da trilha. As taxas
de transferncia atuais esto entre 30 e 80 MB/seg.
bandeja
brao
Cabea de leitura/escrita
eixo
Figura 6.23: Disco rgido
163
6.4.2 Discos pticos

Embora no tenhamos mencionado os discos pticos na hierarquia de
memria, os mesmos esto se tornando muito comuns hoje em dia,
principalmente devido ao advento das tecnologias de regravao e tambm ao
barateamento dos discos compactos (CD).
CD-ROMs so discos de policarbonato recobertos de um fino filme de
alumnio e selado com uma camada de acrlico. O alumnio reflete o laser
verde emitido pelo leitor, que ento detectado por um sensor de luz. Os CDROMs so escritos do centro para as bordas em uma trilha nica espiralada.
Protuberncias no substrato do policarbonato indicam nveis lgicos. Estas
protuberncias so chamadas de buracos (pits), pois assim parecem quando
olhados pela superfcie do CD-ROM. Os pits medem entre 0,83 e 3,56
microns e tm uma largura de 0,5 microns. As protuberncias interferem na
reflexo do laser de tal forma a cancelar a luz emitida e assim provocar
regies de claros e escuros que so interpretadas como nveis lgicos 1 e 0.
O intervalo entre pits chamado de land. Juntando pits e lands, se
pudssemos desenrol-los, teramos um comprimento de 8km de
informaes. A Figura 6.24 mostra um esquema de um disco ptico.
Pits
lands
1,6m
Figura 6.24: Esquema de armazenamento de dados em um CD-ROM
6.4.3 Matrix de Discos Baratos e Redundantes (RAID)

Os primeiros discos magnticos sofriam de males prprios de uma
tecnologia nascente: confiabilidade baixa, tamanho grande e alto custo.
Embora a capacidade dos discos tenha aumentado rapidamente, as melhorias
164
em termos de desempenho nem sempre acompanharam o aumento de

capacidade. Uma matrix de discos baratos e redundantes foi ento proposto
em 1988 por pesquisadores de Berkeley. O termo RAID (Redundant Arrays of
Inexepensive Disks) foi ento cunhado para se contrapor a tecnologia de
discos grande e caros. Os adjetivos so aplicveis poca da introduo da
RAID.
A idia por trs desta matriz distribuir os dados em diversos discos e
usar alguns para redundncia de dados. Esta redundncia importante para
promover maior confiabilidade ao sistema: por exemplo, via de regra, em uma
RAID se um dos discos quebrar os dados no so efetivamente perdidos.
Muitas formas de redundncia de dados podem ser exploradas para obter este
efeito. Como usamos um conjunto de discos para armazenagem dos dados
tambm possvel explorar como dividir nos diversos discos da matriz. Para
classificar os tipos possvel de redundncia e distribuio dos dados nos discos
foram utilizados originalmente 5 nveis distintos (RAID nvel 1 a RAID nvel
5). Estes nveis no formam uma hierarquia e servem basicamente para
identificar que aplicaes se beneficiam das caractersticas da RAID. Apesar
de originalmente propostos 5 nveis, hoje so reconhecidos como padro 7
nveis (adicionando RAID nvel 0 e RAID nvel 6) e existem mais uma gama
de propostas que no so consensuais ou adotadas pela indstria. A propsito,
mesmo dentro dos 5 primeiros nveis propostos alguns no se mostraram
viveis para indstria. Em nosso texto vamos apenas dar uma idia de alguns
dos nveis de RAID, mais freqentemente utilizados.
6.4.3.1 RAID nvel 0
Uma das caractersticas de uma RAID guardar os dados de forma
distribuda, mas sem que o sistema operacional ou usurio perceba. Um
conjunto de dados em seqncia ento distribudo pela matrix, em um
processo chamado striping. Veja que o Sistema Operacional, ao solicitar nos
discos a seqncia de dados, provoca a movimentao de todas as cabeas de
leitura (de cada disco) simultaneamente, favorecendo assim o desempenho do
sistema. Um possvel esquema de distribuio de dados nos discos mostrado
na Figura 6.25. Veja que a informao do ttulo e data de publicao deste
livro est distribuda em 4 discos com 3 bandejas cada.
RAID nvel 0 de fato um nome aproximado para este modelo, j que
nenhuma redundncia provida. De qualquer forma o modelo est
sedimentado com este nome. Exatamente pela falta de redundncia, este o
nvel do RAID que apresenta melhor desempenho. O problema com este
modelo que se existe uma probabilidade matemtica de um dos discos
165
quebrar, como temos uma matriz, a probabilidade de algum dos discos do

conjunto quebrar ainda maior, o que faz com que a confiabilidade do
armazenamento dos dados seja menor. Alm disto, pela falta de redundncia,
impossvel recuperar uma seqncia de dados se algum dos discos apresentar
defeito. Por isto, o RAID nvel 0 recomendado para dados no crticos e que
precisem de alto desempenho de entrada e sada. Sistemas de backup
poderiam utilizar muito bem o RAID nvel 0.
Arqui
tetur
tador
es: a
softw
are,
a de
vis
dez.
Compu
o do
2005
Figura 6.25: RAID nvel 0
6.4.3.2 RAID nvel 1

No RAID nvel 1 est implementada a mais antiga tcnica de tolerncia
a falhas, chamada espelhamento (mirroring) ou sombra (shadowing).
Simplesmente, os dados so replicado dentro da matriz em discos distintos. Se
um disco falhar a informao pode ser obtida de seu disco espelho. Esta
soluo a mais simples e confivel de todos os nveis de RAID, entretanto
ela tambm a mais cara. Seu desempenho parecido com o RAID nvel 0.
Arqui
tetur
tador
es: a
softw
are,
dez.
2005
Arqui
tetur
a de
Compu
tador
es: a
softw
are,
a de
vis
vis
dez.
Compu
o do
o do
2005
166
RAID nvel 1 apropriado para sistemas que precisam de alta tolerncia

a falhas, como sistemas bancrios e de armamentos
6.4.3.3 RAID nvel 2
No RAID nvel 2 os dados so distribudos ao extremo nos discos.
Apenas 1 bit de cada informao guardado em um disco (este valor pode
apresentar variaes dependendo da fonte de pesquisa, mas o fato que as
tiras so muito pequenas). Apenas para formar um byte so necessrios 8
superfcies de discos. Da usado um algoritmo de correo de erro capaz de
detectar e corrigir erros. Os dados necessrios para execuo deste algoritmo
so armazenados em discos extras. Normalmente a quantidade de discos para
armazenar estes dados com informaes de redundncia diretamente
proporcional ao logaritmo do nmero de discos onde esto os dados. O
algoritmo mais convencional para implementar RAID nvel 2 o cdigo de
Hamming.
Este nvel de RAID est em desuso e por isto no vamos prover detalhes
sobre sua utilizao nem seus pontos fortes e fracos.
6.4.3.4 RAID nvel 3
Este nvel de RAID bastante interessante porque garante que usando
apenas um disco extra seja possvel reconstruir a informao original sem que
os dados se percam, em qualquer que seja o disco que por ventura se
danifique. A idia bastante simples, vamos comear com uma analogia para
facilitar a compreenso: imagine que todos os discos de dados da matriz
armazenem nmeros. Um disco extra usado para armazenar a soma de todos
os dados de uma seqncia (cada nmero em um disco). Se algum destes
discos quebrar fcil identificar qual o valor que nele estava armazenado
anteriormente falha simplesmente pegando a soma total, no disco extra, e
subtraindo da soma parcial no restante dos discos.
Na prtica o RAID nvel 3 implementado com uma checagem de
paridade. A paridade simplesmente o resultado do ou-exclusivo de todos os
bits que compem uma determinada seqncia. Os dados do RAID nvel 3
tambm so distribudos bit a bit pelos discos. A Figura 6.26 mostra um
exemplo. O disco cinza usado para guardar bits de paridade. Para primeira
tira, por exemplo, o bit de paridade dado por:
p0 = d00 d10 d2 0 d30 = 1 0 0 0 = 1
167
agora suponha que o disco 2 apresente um defeito e precise ser retirado da

matriz. O sistema entra ento em um modo de operao chamado modo
reduzido. O valor armazenado no disco 2 pode ser calculado da seguinte
forma:
d20 = d00 d10 p0 d30 =1 0 1 0 = 0
No modo de operao reduzida (sem um dos discos) sempre que um
dado solicitado ele precisa ser calculado para ser entregue ao solicitante.
Quando um novo disco introduzido no sistema, em substituio ao disco 2,
todos os dados anteriormente em d2 so calculados e armazenados no novo
disco. Ento o sistema pode voltar a operar em modo normal.
d0
d1
d2
d3
No modo RAID nvel 3 sempre que um dado gravado na matriz, o bit

de paridade associado precisa ser recalculado, mas a leitura no afetada. As
benesses deste modelo se limitam a uma abordagem simples para prov a
redundncia e muito barata, j que exige apenas um disco extra para permitir a
recuperao de informaes. Entretanto, as falhas que ocorram nos discos so
penalizadas em desempenho porque cada informao precisa ser reconstruda.
RAID nvel 3 muito utilizada em sistemas de CAD e tratamento de imagens.
Todos os demais nveis de RAID usam o esquema de paridade para
recuperao de erros, entretanto com algumas diferenas na forma como os
dados so guardados. O leitor est convidado a buscar mais informaes na
web.
Como vimos no RAID nvel 3, o perodo em que um disco apresenta
defeito muito crtico para o sistema. Se durante uma falha ou no perodo de
correo da falha, ocorrer um outro defeito em outro disco, o sistema no ser
168
mais capaz de se recuperar. O RAID nvel 6 usa mais um disco extra para
resolver falhas em mais de um bit, entretanto o preo por maior confiabilidade
pago com discos e mais discos de redundncia.
6.5 Sistema de memrias e desempenho da mquina

Um sistema de memrias apresenta um desempenho geral dependente
dos parmetros de tempo de acesso de seus nveis e quantidade de acertos, por
exemplo: uma cache possui, para um determinado programa, uma taxa de
acerto de 95% e seu tempo de acesso 5ns. A memria principal, seu nvel
inferior, possui em tempo de acesso de 60ns. Qual o tempo de acesso efetivo
na cache?
O tempo de acesso efetivo, EAT (Effective Access Time) definido
como:
EAT = H x TempoAcessoCache + (1-H) x TempoAcessoMemriaPrincipal
Onde H: taxa de acerto na cache.
Ento, para nosso exemplo, EAT = 0,95 x 5ns + 0,05 x 60ns = 7,75ns.
A implicao deste tempo de acesso efetivo de 7,75ns que temos a
iluso de estarmos usando o tempo todo uma memria do tamanho da
principal, mas com a velocidade prxima da cache. Ora, o parmetro mais
sensvel nesta equao a taxa de acerto, por isto importante, ou
mandatrio, tentarmos elev-la ao mximo.
Naturalmente que este clculo pode ser aplicado, em sua semntica,
para os outros nveis da hierarquia, at termos um tempo mdio final
computado.
At o presente momento lidamos com aspectos de desempenho do
sistema de memrias de forma isolada (dentro da prpria hierarquia). Os
aspetos de desempenho do sistema de memria, entretanto, interferem
decisivamente no desempenho do sistema computacional como um todo. O
problema que a tecnologia que nos possibilita guardar grandes quantidades
de dados com um custo aceitvel extremamente lenta se comparada com a
velocidade de operao do processador. Alguns nmeros apontam que a
velocidade de processamento da CPU dobra praticamente a cada 18 meses,
enquanto a velocidade das memrias principais dobra a cada 10 anos. Ora, isto
cria uma barreira chamada de barreira de memria (Memory Wall).
A memory wall minimizada com o uso ostensivo de caches. Via de
regra, as caches funcionam to bem que este problema pouco sentido. Para
se ter uma idia, o Pentium 4 possui dois nvel de cache internas, o que
possibilita acesso a dados/instrues com velocidade compatvel com a CPU.
A questo saber se para todo tipo de aplicao uma determinada

cache, com uma configurao particular, apresenta bom desempenho. Um
computador de uso geral sofre com a mirade de aplicaes e muitas delas mal
comportadas do ponto de vista das caches. No h como prever o desejo do
usurio por algum software em particular, ento o desempenho do sistema
pode ficar aqum das expectativas.
At ento todas as nossas simulaes envolveram a execuo de
instrues de forma que o processador nunca precisasse esperar por um dado,
ou mesmo uma instruo subseqente, estar disponvel. Entretanto, isto est
longe da realidade. Normalmente um software ao ser iniciado se torna mais
lento que o normal, isto porque a cache do sistema de computao est apenas
comeando a buscar dados e instrues que so mais freqentes e por isto,
praticamente tudo precisa ser retirado do disco, posto em memria principal,
levado a cache e s ento chega ao processador.
O tempo de uso do processador pode ser ento expresso como a parcela
em que ele executa as instrues, somada a parcela em que ele fica
aguardando dados e/ou instrues do sistema de memrias.
CPUtempo = CPUexecutando + CPUesperando
O tempo que a CPU fica esperando um dado/instruo determinado
pela quantidade de falhas na cache e a penalidade por erro na cache (miss
penalty). O tempo de acesso cache considerado o mesmo tempo de um
ciclo de clock do processador, o que significa que quando um dado est na
cache o processador simplesmente o requisita e o utiliza imediatamente no
prximo ciclo de clock.
Ento imagine a seguinte situao: uma cache de dados tem uma taxa de
falha de 5% e um processador realiza 100 acessos esta cache. A penalidade
por erro na cache de 10 ciclos por acesso e o cdigo sendo executado usa
500 ciclos de clock, j contabilizadas as falhas na cache de instrues e
interlock de dados. Qual o tempo, em nmeros de ciclos, efetivamente gasto
para executar este cdigo?
De forma simplria podemos dizer que o tempo de CPU efetivamente
executando o cdigo de 500 ciclos. Ora, em 100 acessos cache, 5 deles
resultou em falha, ou seja, 50 ciclos de espera (10x5). O tempo total, em
nmeros de ciclos, ento 500 + 50 = 550 ciclos.
Esta, de fato, uma aproximao porque a penalidade por erro na cache
no inclui falta de pgina, o que, por sua vez, tornaria a penalidade na cache
varivel. Se extrapolssemos a equao para atender tambm a memria
principal, e com ela as faltas de pginas, poderamos perceber que uma falta
169
170
de pgina vertiginosamente mais prejudicial ao desempenho. Desta forma,

muitas vezes prefervel aumentar substancialmente a quantidade, e se
possvel, a velocidade da memria principal que trocar o prprio processador.
6.6 A viso do software

Quando estamos construindo um software enxergamos o sistema de
memria como um repositrio nico e contnuo. At o presente momento
apenas mostramos como esta memria est hipoteticamente dividida em uma
regio de dados e outra de cdigo. Entretanto, por conveno, a regio de
dados do MIPS subdividida em diversas reas. A Figura 6.27 mostra as
reas convencionadas. Existe uma regio de memria reservada para dados
dinmicos, onde so alocados objetos na sua construo, estruturas de
dados, etc. Esta regio comumente denominada heap. Em C, por exemplo,
possvel reservar uma parte do heap com a funo malloc() e liber-la
com a funo free(). Em Java, o new quem aloca espao nesta regio.
Os dados estticos so aqueles comumente encontrados em forma de
variveis declaradas dentro de um programa. Elas ocupam espao na
inicializao do cdigo e no so destrudas durante toda sua execuo. Um
registrador especial o apontador global, $gp ($28). Ele iniciado com o
valor 10008000h de tal forma que possa acessar, com um deslocamento de
16bits no endereamento, de 10000000 h at 1000fffc h.
A regio text o repositrio natural para os cdigos. O apontador de
programas PC iniciado sempre com o valor 00400000 h.
A viso do software
00000000h
PC 00400000h
10000000h
Reservada
Cdigo (text)
Dados Estticos
$gp 10008000h
Dados Dinmicos
(heap)
$sp 7ffffffch
Pilha (stack)
Figura 6.27: Modelo de Memria para o MIPS
A regio de memria mais intrigante e mais importante para o domnio

de nosso curso a pilha. A pilha uma regio em que so guardados dados
especiais e que tem um apontador em particular.
Ns j estudamos como dividir os nossos programas em unidades
pequenas de cdigos chamadas de procedimentos. Sabemos que os
registradores $a0 at $a3 servem para passar parmetros de entrada para os
procedimentos e que $v0 e $v1 devem guardar os resultados das operaes
feitas neste procedimento. Alm disto aprendemos que $ra automaticamente
carregado com o endereo seguinte ao da chamada do procedimento. Bem, a
questo que est faltando responder a seguinte: imagine que um
procedimento A queira chamar outro procedimento B. Quando o
procedimento A invocado, o valor de $ra imediatamente guardado. Se,
dentro de A, houver uma chamada a B, ento um outro valor de endereo
ser salvo em $ra, fazendo com que o endereo de retorno de A seja perdido.
A soluo para este problema o uso da pilha. Guardar o valor de $ra
uma importante tarefa para quem est codificando um procedimento e o
lugar, por excelncia, onde o $ra deve ser guardado a pilha.
Um outro problema que s existem 4 registradores para passagem de
parmetros para o procedimento. E se for preciso passar mais de 4
parmetros? A soluo mais uma vez usar a pilha.
Finalmente, existem alguns registradores que devem ser preservados,
com seus valores originais, aps a execuo de um procedimento. So eles
$s0 at $s7. Cabe ao programador guardar os valores destes registradores
na pilha logo no incio da execuo de um procedimento e reconstitu-los ao
final ao seu estado original.
Vamos comear mostrando um exemplo simples de como guardar os
valores dos registradores $s0 a $s7 na pilha do sistema, quando invocado o
procedimento A.
ProcA:
addi $sp, $sp, -32 # ajusta a pilha mais 8 espaos
sw $s0, 28($sp)
# guarda $s0 na pilha
sw $s1, 24($sp)
sw $s2, 20($sp)
sw $s3, 16($sp)
sw $s4, 12($sp)
sw $s5, 8($sp)
sw $s6, 4($sp)
sw $s7, 0($sp)
........... # cdigos do procedimento
............# podem utilizar $s0 a $s7 localmente
171
A viso do software
172
172
lw $s0, 28($sp)
lw $s1, 24($sp)
lw $s2, 20($sp)
lw $s3, 16($sp)
lw $s4, 12($sp)
lw $s5, 8($sp)
lw $s6, 4($sp)
lw $s7, 0($sp)
addi $sp, $sp, 32 #
jr $ra
# recupera $s0
# recupera $s1
# recupera $s2
# recupera $s3
# recupera $s4
# recupera $s5
# recupera $s6
# recupera $s7
ajusta a pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
menos 8 espaos
Para o caso descrito acima, onde o procedimento A chama o

procedimento B, necessrio guardar tambm o valor de $ra, assim,
teramos:
ProcA:
addi $sp, $sp, -36 # ajusta a pilha mais 9 espaos
sw $ra, 32($sp)
# guarda $ra na pilha
sw $s0, 28($sp)
sw $s1, 24($sp)
sw $s2, 20($sp)
sw $s3, 16($sp)
sw $s4, 12($sp)
sw $s5, 8($sp)
sw $s6, 4($sp)
sw $s7, 0($sp)
........... # cdigos do procedimento A
............# podem utilizar $s0 a $s7 localmente
A viso do software
jal ProcB # chama o procedimento B

........... #
lw $ra, 32($sp)
lw $s0, 28($sp)
lw $s1, 24($sp)
lw $s2, 20($sp)
lw $s3, 16($sp)
lw $s4, 12($sp)
lw $s5, 8($sp)
lw $s6, 4($sp)
lw $s7, 0($sp)
addi $sp, $sp, 36 #
jr $ra
# recupera $ra
# recupera $s0
# recupera $s1
# recupera $s2
# recupera $s3
# recupera $s4
# recupera $s5
# recupera $s6
# recupera $s7
ajusta a pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
na pilha
menos 9 espaos
173
Uma vez sabendo como guardar valores na pilha, o importante saber

que os registradores que sero usados dentro do procedimento, que
porventura sejam $s0 at $s7 devem ser guardados na pilha. Se apenas
alguns deles sero usados, apenas alguns deles devem ser guardados.
Por conveno, os registradores $t0 a $t9 no precisam ser guardados
na pilha, pois servem para armazenar dados temporrios.
6.7 Concluses
Vimos que a hierarquia de memrias nos possibilita um bom
desempenho para sistemas com muita localidade temporal e espacial. Hoje
ainda no esto disponveis sistemas com arquiteturas reconfigurveis o
suficiente para adaptar-se s idiossincrasias dos softwares sendo executados.
Para um programador, resta a grande lio: j que ns no podemos interferir
no hardware que executa nossos programas, devemos prov-los da maior
quantidade possvel de localidade.
A questo pode ser de engenharia reversa: se as caches e mesmo as
memrias principais usam localidade para melhorar o desempenho, um bom
programador vai tambm promover um alto nvel de localidade a fim de que
seu produto seja executado da forma mais rpida e eficaz possvel.
E agora, nos resta pensar como melhorar a localidade. No existem
receitas prontas, mas a prtica nos leva a considerar codificar usando
pequenos laos que sejam muito utilizados; usar o menor nmero possvel de
variveis; fazer mais leituras que escritas de dados; e tentar minimizar
estruturas de deciso e/ou agrup-las ao mximo. Sempre tentar usar variveis
na mesma seqncia em que elas so alocadas (normalmente na ordem em que
foram declaradas, para a maioria das linguagens). Criar objetos e/ou
procedimentos e funes pequenos.
Codificar laos pequenos implica em trazer para cache de instrues
praticamente o lao inteiro. Se o lao for mesmo pequeno pode ser que apenas
um acesso memria principal seja capaz de aloc-lo completamente na
cache. Dispensar laos que sejam executados pouco, ou seja, que tenham
parmetros prximos, como:
for (i=0; i<2; i++){ //.
Um lao deste tipo ser executado apenas trs vezes e embora o cdigo de alto
nvel fique bastante elegante, nem sempre o compilador capaz de
174
transformar esta elegncia em eficincia de execuo. Um programador mais

atento aos aspectos do hardware vai procurar alternativas para no precisar
usar com freqncia tais laos.
Muitas variveis so sempre um transtorno para as caches de dados.
Elas precisam trazer muitas informaes e quase sempre bem aleatrias.
Acessos seqenciais a linhas de uma matriz normalmente causam na cache de
dados muitas falhas. Procurar agrupar as variveis usadas no cdigo de tal
forma que eles estejam na circunvizinhana ajuda a explorar a localidade
espacial das caches.
Tambm bastante complicado o processo de escrita nas caches.
Principalmente porque costumamos declarar as variveis de sada bem
distantes das variveis de entrada. Alm disto, transferir dados para memria
principal sempre custoso. A idia usar variveis temporrias, que
normalmente so reconhecidas pelo compilador, e somente depois de um
longo processamento escrever os dados finais na memria.
Estruturas de deciso, como if-then-else provocam desvio no fluxo do
programa o que pode fazer com que a cache perca boa parte das instrues que
foram carregadas em um bloco. Ao usar instrues de desvio vamos procurar
ser tendenciosos por um caminho preferencial, o que pode fazer com que o
algoritmo de previso de desvios funcione bem e busque as instrues corretas
para cache, desperdiando minimamente buscas memria principal.
Estruturas de controle agrupadas permitem que as instrues de mquina de
desvio de fluxo fiquem muito prximas umas das outras e isto potencializa o
aproveitamento de um bloco.
Objetos pequenos, normalmente podem ser carregados do disco para
memria principal em uma nica pgina. Quando codificamos objetos
grandes, apenas partes so carregadas por vez e isto pode degradar o
desempenho.
Existe um caso especial que nos faz ser ainda mais precisos na
construo de nossos softwares: quando conhecemos a arquitetura da
hierarquia de memria onde nosso software vai ser executado. Neste caso,
de suma importncia uma simulao da hierarquia de memrias de tal forma
que se possa identificar quais trechos do cdigo promovem o maior nmero de
falhas e faltas. Reescrev-los uma boa idia! Um caso prtico demonstra que
para aplicaes crticas, envolvendo, por exemplo, um sistema de controle de
respirao artificial de uma UTI, as partes que mantm o sistema operativo
devem ser construdas em assembly para garantir o desempenho esperado, sem
envolver incertezas.
Estas dicas apresentadas so apenas lucubraes, mas no so
limitantes. O importante que um programador comece a se preocupar com a
qualidade do desempenho do seu software, usando para isto os conhecimentos

sobre as mquinas onde eles so executados. Os compiladores otimizantes
ajudam bastante, mas sua tarefa rdua e complexa. Ajud-los uma
bondade.

Existe um gama de softwares capazes de simular o desempenho do
sistema de memrias. O mais conhecido deles, certamente o dinero. Este
software capaz de simular a operao de uma cache com as mais variadas
configuraes, inclusive caches multi-nveis. Sua operao baseada em
comando de linha e os resultados apresentados em forma de quantidade de
falhas. Caches de dados e instrues separadas podem ser simuladas
simultaneamente. Os dados de entrada so uma seqncia de referncias
memria.
O
dinero
pode
ser
obtido
em
http://www.cs.wisc.edu/~markhill/DineroIV/, (acesso em dez, 2005),
inclusive com explicaes sobre seu uso e instalao.
Uma desvantagem do uso do dinero sua interface com o usurio. De
fato, nenhum dado na memria mostrado. Por isto, na pgina web associada
a este livro est disponvel um software simulador de cache, LBGCache, com
interface grfica que se ajusta melhor esta fase do aprendizado. Baixe o
software e explore os exemplos propostos no site.
6.9 Exerccios
6.1
6.2
6.3
6.4
6.5
Pesquise na web e produza um resumo sobre Scratchpad memories.

Pesquise na web e produza um resumo sobre Memory segmentation.
Pesquise na web e produza um resumo sobre Memria Intercalada.
Pesquise na web e produza um resumo sobre Intelligent RAM.
Pesquise na web e produza um resumo sobre compulsory, conflict e
capacity misses.
6.6 Pesquise na web e produza um resumo sobre nonblocking cache.
6.7 Pesquise na web e produza um resumo sobre Loop Cache.
6.8 Pesquise na web e produza um resumo sobre Victim Cache.
6.9 Pesquise na web e produza um resumo sobre RAID nveis 4, 5 e 6.
6.10 Como so classificados os discos rgidos (RAM, seqencial, ROM,
voltil)?
6.11 Mostre em pseudo-cdigo um exemplo de programa que exibe baixa
localidade espacial, com respeito a dados.
175
176

localidade temporal, com respeito a dados.
localidade espacial, com respeito a cdigo.
localidade temporal, com respeito a cdigo.
6.15 Em um cdigo que exige muito acesso de escrita a dados, qual poltica
de escrita voc sugeriria para uma cache?
6.16 Esboce o esquema de uma cache com capacidade de 4kbytes, 16 bytes
por blocos, 2-way set associative.
6.17 Esboce o esquema de uma cache com capacidade de 4kbytes, 16 bytes
por blocos, 4-way set associative.
6.18 Use a mesma seqncia de acessos do exerccio da Figura 6.14, mas
com uma cache de 512bytes, 16 conjuntos e 4 palavras/bloco. Indique
qual o desempenho em termos de quantidade de falhas.
6.19 Use a mesma seqncia de acessos do exerccio da Figura 6.14, mas
com uma cache de 512bytes, 32 conjuntos e 1 palavra/bloco. Indique
qual o desempenho em termos de quantidade de falhas.
6.20 Repita os exerccios 6.18 e 6.19 usando uma poltica de substituio de
linhas, onde o ltimo (mais recentemente) elemento acessado o
primeiro a ser retirado da cache.
6.21 Em um sistema com endereo virtual de 32 bits, pginas de 4kbytes e
4 bytes por linha na tabela de pginas, calcule o tamanho da tabela de
pginas para um programa.
6.22 O que aconteceria em um sistema com 128Mbytes de memria
principal que esteja executando simultaneamente 100 aplicaes com
as mesmas caractersticas do exerccio 6.23 O hot-swap uma
tcnica que permite a troca de um equipamento computacional sem
que o sistema seja desligado. Todos os nvel de RAID permitem hotswap de discos? Por que?
6.24 Desenhe (esquematize) um sistema contendo cache e memria virtual
operando juntas.
6.25 Um sistema roda uma nica aplicao com desempenho da cache de
90% de acertos e 80% de acertos na memria principal. Considerando
os tempos de acesso mnimos explicitados na Figura 6.1, qual o tempo
de acesso efetivo do sistema de memrias?
6.26 Descreva como um procedimento recursivo deve utilizar a pilha do
sistema. Exemplifique com uma implementao do fatorial.
6.10 Referncias Bibliogrficas Especficas

[6.1] Maurice Wilkes. Slave memories and dynamic storage allocation. IEEE
Transactions on Electronic Computers, EC-14:2 (April), 1965, pp.
270-271.
[6.2] David Patterson, Garth Gibson and Randy Katz. A case for redundant
arrays of inexpensive disks (RAID). In Proceedings of the 1988 ACM
SIGMOD international conference on Management of data, pp 109116
177
178
Captulo 7
Entrada e Sada
7.1 Introduo
Agora j conhecemos trs componentes bsicos de um computador: a
unidade de controle; a via de dados; e o sistema de memrias. Conhecemos os
principais aspectos das linguagens de programao de baixo nvel, seja
linguagem de montagem, seja linguagem de mquina e agora vamos terminar
nossa explorao pelo sistema de entrada e sada (E/S ou I/O, Input/Output).
Um computador teria uma utilizao mnima se no houvesse meios de
aliment-lo com dados e extrair informaes do mesmo. A entrada e sada de
dados que permite a ns, seres humanos, interagir com a mquina. O
processamento dos dados, como visto na Figura 5.1, depende de muitos
fatores, inclusive da eficincia do sistema de entrada e sada.
Mesmo que tenhamos um sistema de memrias muito eficaz, uma CPU
muito rpida e um sistema operacional que consumisse um mnimo de tempo,
de nada adiantaria se a entrada de dados, via teclado, por exemplo, fosse muito
lenta. Assim tambm, se ao digitarmos um caractere no teclado este levasse
minutos at ecoar no monitor de vdeo, por ineficincia do sistema de sada de
dados, a experincia homem-mquina seria frustrante. Portanto, neste captulo,
tambm lidamos com um fator essencial ao processamento de informaes.
Antes de abordarmos o sistema de entrada e sada propriamente dito,
vamos conhecer um elemento significativo no trnsito dos dados: o
barramento. Um barramento um conjunto de fios, dispostos logicamente
lado a lado, com caractersticas eltricas prprias, que transfere uma
informao de um ponto a outro de um sistema computacional. Um
barramento pode ter uma funo especfica dentro de um computador, por
exemplo, um barramento de endereos leva apenas endereos de um ponto a
outro do sistema. Um barramento de dados, porta apenas dados. Um
barramento de controle carrega sinais de controle.
179
180
De uma certa forma j conhecemos os barramentos de comunicao

entre o processador e a hierarquia de memrias. Vamos recapitular a Figura
1.4, que mostra os componentes do computador adaptando-a para mostrar os
barramentos de endereo e dados. A re-edio est apresentada na Figura 7.1.
Sabemos que o processador, quando deseja um dado que est na memria,
disponibiliza o seu endereo (do dado) no barramento de endereos e aguarda
at que o mesmo esteja disponvel no barramento de dados.
O caso da escrita semelhante, ou seja, o processador disponibiliza o
dado a ser escrito no barramento de dados e coloca o endereo no barramento
de endereos. Veja que o processador sempre seta o endereo no barramento
de endereos. Isto no o que ocorre com os dados, que podem vir da
memria ou do processador. Por isto, na figura, o barramento de endereos
unidirecional e o barramento de dados bidirecional.
O que est faltando na Figura 7.1 o barramento de controle por onde
so enviados sinais da CPU para memria. Um sinal tpico deste barramento
o sinal de escrita e leitura na memria. O processador precisa informar
hierarquia se deseja escrever ou ler um dado, ento preciso definir um sinal
que quando setado signifique escrita e quando ressetado signifique leitura.
COMPUTADOR
RECEITAS
BARRAMENTO DE
ENDEREOS
MEMRIA
S
RE E T O
CEI R
TA
S
0
16
32
20
36
24
40
12
28
44
48
64
80
52
68
84
CONTROLE
S
TE E T O
MPE R
RO
S
VIA DE DADOS
1
2
3
4
PROCESSADOR
BARRAMENTO DE
DADOS
ENTRADA
56
72
88
60
76
92
SE
BO T O R
LO
S
SE
CA TO R
RNE
S
SADA
96
112
128
100
116
132
104
120
136
108
124
140
Figura 7.1: Componentes de um Computador
181
Captulo 7: Entrada e Sada
Um barramento um canal de comunicao que pode ser compartilhado

por mais de dois componentes de um computador. A largura de um
barramento a quantidade de fios, tambm chamadas de linhas de
comunicao, que ele contm. Por exemplo, um barramento com largura de
32 bits, significa um barramento que pode transferir 32 bits simultaneamente
de um ponto a outro em um determinado intervalo de tempo.
As caractersticas eltricas dos barramentos, como largura das linhas e
proximidade entre linha, alm do grau de interferncia eletromagntica,
definem caractersticas como a freqncia mxima de transferncia de dados.
Um mdulo de E/S tambm conectado ao processador via
barramentos. O mdulo de E/S responsvel pelo funcionamento dos
perifricos de entrada de dados e de sada de dados, como teclado e monitor,
respectivamente. Um mdulo de entrada e sada um dispositivo fsico,
normalmente contendo alguns portos, onde so colocados dados e palavras de
status. Um porto (ou porta) endereado como se fosse uma posio de
memria e sinais de controle especficos so necessrios para indicar quando
se est fazendo uma leitura ou uma escrita em um determinado dispositivo de
entrada ou sada.
A Figura 7.2 mostra o esquema de compartilhamento dos barramentos e
diversos dispositivos de entrada e sada, junto com o processador e a memria.
Para acessar um dispositivo de entrada ou sada o processador informa no
barramento de endereos o nmero do dispositivo e envia ou recebe dados via
barramento de dados. Sinais de controle especficos so usados para fazer
leitura ou escrita nos dispositivos de entrada e sada.
Processador
Memria
Dispositivo de
E/S (teclado)
Status
Porto # 8
Dispositivo de
E/S (impressora)
Status
Porto # 9
Dispositivo de
E/S (monitor)
Status
Porto # 10
BARRAMENTO DE ENDEREOS
BARRAMENTO DE DADOS
BARRAMENTO DE CONTROLE
Figura 7.2: Barramentos de Interconexo dos componentes de um computador
182
Existem duas formas de endereamento dos dispositivos de E/S:

endereamento especfico e mapeamento em memria. No primeiro caso um
nmero est associado a cada dispositivo e o processador precisa ter
instrues especficas em sua ISA para fazer entrada e sada, tipicamente
instrues in $reg, dispositivo e out $reg, dispositivo.
No segundo caso, um endereo de memria (ou vrios) est associado a cada
dispositivo de E/S. Nesta situao, uma simples instruo de load ou store
capaz de ler ou escrever dados em dispositivos externos. O mtodo de
mapeamento de E/S em memria mais simples, mas reserva algumas
posies de memria para uso pelos dispositivos, o que diminui o espao de
endereamento do processador. A Figura 7.3 mostra os dois mtodos de
endereamento possveis.
Memria
Memria
fffffffch
fffffffch
ffffffc0h
(a)
Entrada e
Sada
(b)
00000040h
63
00000000h
Entrada e
Sada
00000000h
Figura 7.3: Espaos de endereamanto de Memria e E/S

(a) separados e (b)unificados
7.2 Mtodos de Controle de E/S

Existem basicamente trs mtodos de controle de entrada e sada:
pooling (ou entrada/sada programada); E/S por interrupo; e acesso direto
memria, DMA (Direct Memory Access).
Na entrada e sada programada o processador fica em um estado de
inquisio para os dispositivos de E/S. Em cada dispositivo verificada a
palavra de status. Se um dado foi enviado ao dispositivo, ou chegou de um
dispositivo, o registrador de status do controlador alterado o que permite ao
processador saber se existem dados a serem tratados.
Este um mtodo simples de implementar, o problema que alguns
dispositivos tm uso em rajadas, como o caso do teclado. Podemos perceber
que enquanto estamos digitando algo, normalmente paramos para pensar nas
palavras, nas frmulas ou mesmo no design do texto, figura ou o que quer que
seja. Em outros instantes digitamos uma seqncia de caracteres de forma bem
rpida (uma rajada). Nos intervalos entre rajadas o processador ficaria
perguntando ao teclado se existe um novo dado e este responderia sempre que
no.
Na segunda hiptese de transferncia de dados, o processador no se
preocupa em perguntar aos dispositivos se existem novos dados, mas o prprio
dispositivo pede ao processador sua ateno usando um pedido de interrupo.
Neste caso o processador deve parar a execuo do processo corrente e
atender ao dispositivo que o chama.
Finalmente o processo de DMA desafoga o processador do controle de
entrada e sada dos dados entre a memria e o dispositivo perifrico.No DMA
o processador usa um dispositivo externo, chamado controlador de DMA,
para programar as transferncias de dados. Tipicamente, o processador
informa os endereos da memria e do dispositivo de E/S envolvidos na
transao e a quantidade de dados a ser transferida. Depois ele libera os
barramentos para uso e controle do controlador de DMA. O processo de
transferncia de dados diretamente para memria implica no acesso aos
barramentos do sistema (barramento de endereos, dados e controle que
interliga o sistema de memrias, o processador e os dispositivos de E/S).
preciso um rbitro para os barramentos a fim de garantir que cada mdulo os
utiliza no momento adequado. Aqui, neste exemplo didtico, o papel do
rbitro desempenhado pelo processador.
O fato de interligar o sistema de memria e os dispositivos de entrada e
sada no mesmo conjunto de barramentos tem uma implicao imediata: por
natureza os dispositivos de E/S so assncronos, ou seja, no se pode prever
uma certa quantidade de ciclos de clock para a resposta de tais dispositivos.
Por outro lado, num sistema de memria, poderamos indicar um
funcionamento sncrono com o processador, definido pela velocidade das
memrias e do prprio processador. Ento, uma possibilidade de operao
conjunta, embora exeqvel, pode no ser a melhor opo. Costumeiramente
usamos barramentos sncronos separados para o acesso memria e
barramentos assncronos dedicados aos dispositivos de entrada e sada.
Esta forma de separar os barramentos acaba promovendo uma
hierarquizao dos mesmos. Um conjunto de barramentos muito rpido
poderia interligar o processador cache, que por sua vez utilizaria um outro
conjunto de barramentos para se comunicar com a memria principal e
finalmente, a partir destes ltimos barramentos, poderia haver uma interface
para um conjunto de barramentos de expanso onde so interligados os
dispositivos de entrada e sada. A Figura 7.4 mostra o esquema tradicional.
183
184
Processador
Memria
Cache
BARRAMENTOS LOCAIS
Memria
Principal
BARRAMENTOS DE SISTEMA
Ponte
Interface
Serial
Rede
SCSI
Modem
BARRAMENTOS DE EXPANSO
Figura 7.4: Hierarquia de barramentos de interconexo
Na prtica esta hierarquia definida com as velocidades de transmisso

de dados suportadas por cada barramento. O exemplo da Figura 7.5 mostra
uma abstrao da hierarquia de barramentos do Pentium 4. A ponte norte
interconecta a memria principal, a sada grfica de alta velocidade, chamada
AGP e uma porta de alta velocidade de rede, chamada de GigaBit Ethernet. A
ponte sul interliga os dispositivos de entrada e sada ponte norte e age como
um controlador de DMA.
Esta organizao hierarquizada est disposta dentro da placa me e tem
caractersticas particulares, por exemplo, numa placa me com chip set Intel
845GL a velocidade dos barramentos de sistema de apenas 400MHz, j com
o chip set 875P esta velocidade de 800 MHz. O primeiro chip set utiliza uma
ponte norte que tem 760 pinos, enquanto o segundo utiliza uma ponte norte
com 1005 pinos. O nmero de portos PCI, USB etc. tambm diferem de chip
set para chip set. A propsito, um chip set, o conjunto de chips prximos do
processador que servem para interfacear a placa me com os diversos
dispositivos do computador.
185
Pentium 4
BARRAMENTOS DO SISTEMA (800MHz, 604 GB/s)
Memria
Principal
(DIMM)
AGP
2.1GB/s
DDR 400
3.2GB/s
DDR 400
3.2GB/s
Ponte Norte
CSA
266MB/s
Sada Grfica
GigaBit
Ethernet
BARRAMENTOS DE EXPANSO (266 MB/s)
Discos
SERIAL ATA
500 MB/s
PARALLEL ATA
100 MB/s
Ponte Sul
USB
60 MB/s
20 MB/s
CD/DVD
TAPE
10/100 Mbit
Ethernet
PCI
132 MB/s
Figura 7.5: Hierarquia de barramentos de interconexo do Pentium 4
Quando utilizamos barramentos assncronos preciso definir um

conjunto de passos atravs dos quais o processador ir se comunicar com o
dispositivo de entrada e sada. Este conjunto de passos implementado com a
insero de sinais de controle entre as partes comunicantes. Por exemplo, um
dispositivo de entrada de dados requer a ateno do processador a partir de um
pedido de interrupo. Ele ento deve disponibilizar no barramento de
endereos a sua identificao e setar o sinal INTR (INTerrupt Request) do
barramento de controle. O processador indica que recebeu tal pedido e est
pronto para process-lo setando o sinal INTA (INTerrupt Acknowledge).
Ento o dispositivo disponibiliza os dados e assim sucessivamente.
Este protocolo de sinais chamado de handshaking, ou seja, um acordo
de comunicao que deve ser fechado entre as partes comunicantes antes do
incio da transmisso/recepo dos dados. Existem protocolos padronizados e
todo dispositivo que quiser se comunicar com o processador deve implementar
o protocolo apropriado.
186
Estes protocolos tambm sugerem uma hierarquia. Considere o caso em

que dois dispositivos distintos levantam o sinal INTR pedindo uma
interrupo ao processador. Como o mesmo ir responder? Haveria alguma
prioridade? A resposta : sim. Normalmente os processadores possuem apenas
um conjunto de linhas para indicar um pedido de interrupo, ento preciso
utilizar um dispositivo externo, chamado controlador de interrupes, para
controlar qual dispositivo deve ser atendido primeiro. O mais famoso
controlador de interrupes o chip 8259 da Intel. Ele processa at 8 pedidos
de interrupo simultaneamente. possvel cascate-lo potencializando uma
expanso para at 64 dispositivos de E/S, como mostra a Figura 7.6.
8259 ESCRAVO
DISPOSITIVO EXTERNO 00
...
...
IRQ0
IRQ1
IRQ2
IRQ3
IRQ4
IRQ5
IRQ6
IRQ7
IRQ0
IRQ1
IRQ2
IRQ3
IRQ4
IRQ5
IRQ6
IRQ7
...
...
INTR
8259 MESTRE
INTR
...
...
IRQ0
IRQ1
IRQ2
IRQ3
IRQ4
IRQ5
IRQ6
IRQ7
IRQ0
IRQ1
IRQ2
IRQ3
IRQ4
IRQ5
IRQ6
IRQ7
INTR
SINAL INTR PARA O PROCESSADOR
INTR
Figura 7.6: Controlador de Interrupes 8259 em cascata
O 8259 programvel e pode decidir prioridades de atendimento para

cada pedido de interrupes. Mouse, teclado, discos e impressoras costumam
utilizar interrupes para se comunicar com o processador.
Este tipo de interrupo chamada de interrupo por hardware que ns
iremos tratar a seguir na seo da viso do software, dando nfase ao processo
do atendimento da mesma.
7.3 A viso do software Interrupes

Mas afinal, o que acontece com um software que est sendo executado
por uma mquina quando ocorre uma interrupo? Qualquer que seja a
forma, o tratamento da interrupo resume-se a interromper o
processamento para atender o pedido. um caso semelhante a uma chamada
187
de procedimento, mas aqui, a interrupo pode ser gerada em qualquer

instante e a instruo que foi interrompida (se no finalizada) ir ser
executada novamente. Ento, um fato importante saber como uma
interrupo gera o endereo do procedimento que ir trat-la, normalmente
chamado de rotina de tratamento de interrupo.
Em uma parte do sistema operacional, ficam guardadas as rotinas de
tratamento de interrupes. Os endereos de cada rotina ficam guardados em
uma tabela chamada Vetor de Interrupes. Quando ocorre uma
interrupo, o dispositivo que o gerou responsvel por identific-lo
dispondo no barramento de endereos o nmero associado. Este nmero
usado como ndice do vetor de interrupes de tal forma que o endereo
adequado da rotina de tratamento possa ser carregado no PC.
A Figura 7.7 mostra um exemplo do que ocorre quando uma
interrupo, por exemplo, uma tecla digitada no teclado, gerada pelo
dispositivo de entrada. O processador estava executando uma instruo
addi quando a interrupo foi pedida. O processador ento verifica suas
linhas de endereos para detectar que a interrupo nmero 1 foi gerada. O
sistema Operacional toma conta da CPU, salvando todo contexto da
aplicao que estava sendo executada e apontando para o local da memria
onde fica o vetor de interrupes. O ndice que ser observado neste caso o
prprio nmero da interrupo. O valor contido nesta posio do vetor
ento carregado em PC, o que causa um desvio para a rotina de tratamento
da interrupo. Ao fim desta rotina, o fluxo de execuo volta para instruo
add com todo contexto do processo do usurio restaurado pelo SO.
fffff114h
fffff110h
Vetor de
Interrupes
80000180h
00000120h
00000110h
00000100h
add $8, $8, $10

addi $8, $9, 5
Reservado ao
Usurio
Interrupo
nmero 1
00000100
00000110
00000120
fffff114
EPC
00000110
PC
rot_trat_int_0
rot_trat_int_1
rot_trat_int_2
Reservado ao
Sistema Operacional
00000000h
Figura 7.7: Tratamento de Interrupo
A viso do software
fffffffch
188
Especificamente no MIPS existe um registrador chamado EPC que

guarda o valor do PC antes da ocorrncia da interrupo, permitindo assim
que ao fim da rotina de tratamento da interrupo o valor de PC seja
restaurado corretamente.
O MIPS tambm tem um registrador chamado cause, onde o nmero
da interrupo depositado e a partir da o sistema operacional pode
implementar sua tabela de interrupes e usar o valor de cause para ser o
seu ndice.
Existe uma nomenclatura no universal sobre a definio de exceo.
Em tese, uma exceo um tipo de interrupo gerada dentro do prprio
processador, como um overflow. A exceo tratada da mesma forma de
uma interrupo, ou seja, dentro do mesmo vetor de interrupes h os
endereos das rotinas de tratamento de excees. Esta nomenclatura
particular usada no MIPS, mas a Intel no faz distino entre interrupo e
exceo.
A propsito, o MIPS tambm considera uma chamada ao sistema
operacional como uma exceo. Uma chamada ao SO definida como um
acesso a um servio que o software do usurio no pode prestar. Por
exemplo, um software do usurio no pode escrever diretamente na tela do
computador, ento ele utiliza uma chamada ao SO que permite ter os
privilgios suficientes para escrever um dado na tela. A instruo syscall
utilizada para prover esta chamada, no nvel do software do usurio.
7.4 Concluses
Neste captulo aprendemos como as vias de comunicao de
processador interligam seus componentes e como o mundo exterior se
comunica com o computador.
Os barramentos do sistema so basicamente de dados, de endereos e de
controle. Os barramentos podem ser hierarquizados de acordo com sua largura
e freqncia de operaes.
Os dispositivos de Entrada e Sada so mdulos que se comunicam com
os perifricos de um computador. Estes mdulos so acessados pelo
processador usando os barramentos de expanso e podem ser mapeados em
memria ou podem ter sua numerao independente.
O controle de Entrada e Sada de dados feito pelo processador de trs
formas distintas, programada, por interrupo e por DMA. As interrupes so
tratadas por mdulos de softwares chamados de rotinas de tratamento de

interrupes.
Muitas so as tecnologias que ajudam na velocidade de transmisso de
dados de um ponto a outro de um computador. A maioria baseia-se no
aumento da largura dos barramentos e/ou na freqncia de operao dos
mesmos. As tecnolgicas poderiam ser historicamente relembradas, como RS232, IDE, ATA, SCSI, USB, Fire wire etc. Certamente este material j estar
desatualizado em pouco tempo, pois estas tecnologias surgem efusivamente no
dia-a-dia.
Outra importante lio como o software do usurio pode pedir ao
sistema operacional para usar seus servios. Esta ser abordada, no caso
particular do SPIM na prxima seo.

Nesta seo vamos mostrar como o SPIM pode se comunicar com o
mundo externo. Quando iniciamos o SPIM surgem duas janelas: a primeira
chamada PCSpim e a segunda chamada console. O console serve de meio de
comunicao com o mundo exterior, sendo o ponto de entrada de dados,
simulando o teclado, e o ponto de sada de dados, simulando o monitor de
vdeo.
A interao do software do usurio com o console feita atravs do uso
da instruo syscall. Diversos servios so implementados como escrita de
um nmero inteiro, de um nmero real, de uma string, ou a leitura destes
dados. Para que a instruo syscall execute o servio apropriado preciso
antes identific-lo, alimentando o registrador $2 com o nmero do servio.
Quando trata-se de uma escrita de dados preciso ainda dizer qual dado
deve ser escrito. Este dado normalmente especificado em $4. O resultado de
uma leitura disposto em $2, exceto no caso de uma leitura de uma string,
onde $4 tem o endereo da string e $5 contm o seu tamanho.
A Tabela 7.1 mostra algumas das chamadas de sistema implementadas
no SPIM e seus respectivos argumentos.
189
190
Servio
Imprime inteiro
Imprime string
Cdigo ($2)
1
4
L inteiro
L string
5
8
Fim da execuo
10
Argumentos
$4 = inteiro
$4 = endereo da
string
Resultados
$2 inteiro
$4 = endereo
$5 = tamanho
Tabela 7.1: Cdigos associados ao SYSCALL
Vamos ento verificar como podemos criar um programa que leia dois
dados do usurio, realize a soma e escreva o resultado.
.data
.asciiz "soma = " # define uma string
.text
main:
addi $2, $0, 5 # servio 5 (l inteiro)

syscall
add $8, $2, $0 # guarda valor lido em $8
addi $2, $0, 5 # servio 5 (l inteiro)
syscall
add $8, $2, $8 # soma os dois valores
lui $4, 0x1001 # endereo da string
addi $2, $0, 4 # servio 4 (escreve string)
syscall
add $4, $0, $8 # soma em $4
addi $2, $0, 1 # servio 8 (escreve inteiro)
syscall
7.6 Exerccios
7.1
Pesquise na web e produza um resumo sobre os tipos de dispositivos

de entrada e sada.
7.2 Pesquise na web e produza um resumo sobre os barramentos SCSI
7.3 Pesquise na web e produza um resumo sobre os barramentos PCI.
7.4 Pesquise na web e produza um resumo sobre os barramentos USB.
7.5 Pesquise na web e produza um resumo sobre os barramentos FireWire.
7.6 Pesquise na web e produza um resumo sobre arbitragem de
barramentos.
7.7 Pesquise na web e produza um resumo sobre roubo de ciclos pelo
barramentos.
7.8 Mostre com a transferncia de dados de um disco conduzida usando
E/S programada, por interrupo e por DMA.
7.9 Crie um programa para o SPIM que leia dois inteiros e realize a
operao xy.
7.10 Crie um programa para o SPIM que leia as notas dos alunos de uma
turma e calcule a mdia. Para parar de receber notas, o usurio deve
informar um valor negativo.
7.11 Crie um programa para o SPIM que leia os parmetros de uma cache e
desenhe, com caracteres, a diviso dos endereos.
191
192
Captulo 8
Concluses
8.1 Introduo
Chegamos ao fim deste livro com um conhecimento bsico da
organizao de um computador. O conjunto de assuntos estudado nos serve de
alicerce para implementaes reais. A indstria do hardware evolui
rapidamente em nossos tempos, aproveitando os conhecimentos adquiridos em
anos de experimentos. Entretanto, muitas so as tecnologias e nomes
atribudos a conceitos bsicos e avanados desta rea do conhecimento. A
questo do marketing leva as empresas a usarem uma nomenclatura particular
para suas novas implementaes, muitas vezes descobertas dentro de um
ambiente acadmico ou em cooperao com centros universitrios.
Um estudante que tenha usado este material deve estar apto a aprender
novas linguagens de mquina, usar montadores e compreender como ocorre o
processo de traduo de uma linguagem de alto nvel em cdigos binrios
inteligveis para a mquina. O sistema de memrias ocupa uma grande regio
do projeto de um processador e melhorias nele podem promover grandes
benefcios no desempenho real de uma mquina, por isto a hierarquia de
memrias bastante explorada no texto.
Estudamos neste texto uma linguagem de montagem (do MIPS) e sua
correspondente linguagem de mquina. Conhecemos os principais
componentes de uma organizao, baseada na escola de Von Neumman.
Vimos sua interligao com o uso de barramentos e conhecemos o canal de
comunicao da mquina com outras mquinas e tambm com os seres
humanos. Descobrimos ainda, como mensurar a eficincia de um computador.
A experincia a verdadeira escola do processo ensino-aprendizagem.
Sob este prisma, a leitura deste texto municia o aluno para o uso de diversos
simuladores o que permite uma abordagem mais prtica de um assunto to
complexo.
193
194
8.2 Realidades
Assim como no mundo do software existem muitos avanos constantes,
no mundo do hardware as tcnicas e tecnologias tambm so eclticas. Ns
estamos chegando ao fim de uma era de evolues de um modelo de
processador que centraliza e controla todas as operaes de um computador e
que tem as tecnologias de fabricao, com freqncias de operaes cada vez
maiores, como arma para melhoria de desempenho de um produto sobre outro.
Este processo, assim como o petrleo, tem um fim anunciado, com previses
ainda obscuras, mas o fato que a nova ordem o trabalho colaborativo,
explorando a possibilidade de paralelismo entre as tarefas.
Existem diversos modelos de paralelismo que podem ser explorados. O
primeiro deles o de uma mquina com superpipelines. A observao que
gerou este conceito que muitas das tarefas em um estgio de um pipeline
convencional pode ser quebrada em subtarefas o que nos permite aumentar a
freqncia de operao e produzir mais resultados por ciclos de clock. Outra
possibilidade o pipeline superescalar onde muitas unidades de execuo so
dispostas em paralelo e mesmo a busca e a decodificao so feitas em pares,
ou quadras. Para termos uma idia de como estas implementaes de nossos
dias podem interferir no desempenho de uma mquina vamos analisar a Figura
8.1 que mostra a execuo de seis instrues numa mquina pipeline
convencional e numa mquina com superpipeline. O clock o mesmo
utilizado na Figura 4.14, com um perodo de 6ns.
Neste exemplo a mquina com superpipeline quebra a tarefa realizada
em cada estgio em duas partes o que permite em um mesmo ciclo de clock
realizar duas operaes ao mesmo tempo. Esta vantagem permite que o
programa como um todo seja concludo mais rapidamente.
A Figura 8.2 mostra, com a mesma base de tempo da Figura 8.1, a
diferena de uma execuo do mesmo exemplo em uma mquina superescalar
de dois nveis, ou seja, que trata duas instrues por vez. A mquina
superescalar apresenta melhor desempenho entre as trs, produzindo mais
instrues por ciclo de clock. Infelizmente, mquinas superescalares convivem
com uma realidade menos animadoras: as dependncias de dados no
permitem que se explore ao mximo o paralelismo de instrues. A propsito,
toda dependncia de dados tenta ser tratada, pelo hardware, antes que as
instrues sejam enviadas para o ciclo de execuo. Este tratamento em
hardware bastante complexo, mas tem uma grande benesse: no preciso a
re-compilao ou re-escrita dos cdigos executveis.
Captulo 8: Concluses
195
E
D
F
D
F
D
F
D
F
Mquina
pipeline
D
F
D
F
D
F
W
M
D
F
Mquina
Superpipeline
W
M
E
W
M
clock
tempo
18ns
36ns
54ns
60ns
Figura 8.1: Comparao de uma mquina pipeline com uma superpipeline
196
D
F
D
F
D
F
D
F
Mquina
pipeline
D
F
Mquina
Superescalar
clock
tempo
18ns
36ns
54ns
60ns
Figura 8.2: Comparao de uma mquina pipeline com uma superescalar
Captulo 8: Concluses
Uma outra classe de mquina que compartilha o mesmo paradigma de

paralelismo no nvel de instrues a mquina VLIW (Very Long Instruction
Word). Nesta mquina uma instruo tem mais de 32 bits de largura,
chegando a algo em torno de 128 bits o que permite a realizao de 4
instrues em paralelo. A diferena entre uma mquina VLIW e uma
superescalar basicamente o ator que encontra o paralelismo das instrues
para serem exploradas. Numa mquina VLIW esta tarefa do compilador que
precisa alocar as operaes corretas dentro das instrues. O compilador, por
se tratar de um software, pode explorar melhor o paralelismo, mas por outro
lado os programas existentes precisam ser recompilados para o uso em uma
mquina VLIW.
Uma outra possibilidade de explorao de paralelismo o uso de
diversos processadores em paralelo, cada qual executando um programa, ou
partes de um programa, que possam ao final se comunicar para produzir um
resultado. Este tipo de organizao chamado de multi-processador e
tambm tem enorme implicao na forma como construmos os nossos
softwares.
8.3 Alm das Realidades

O futuro prximo das arquiteturas certamente passa por paralelismo. J
somos capazes de fabricar em um nico chip um conjunto de processadores e
interlig-los por meio de uma rede programvel dentro do prprio chip, so as
chamadas NoCs (Network-on-Chip). Alguns experimentos com NoCs esto
sendo iniciados em diversas universidades e em algumas indstrias. Este
modelo interessante pois permite a interligao de diversos processadores
com arquiteturas diferentes em uma nica pastilha de silcio. Atualmente
estamos trabalhando na permissividade de operao dos diversos componentes
da NoC em freqncias distintas.
Outra frente de pesquisa em andamento a reconfigurao de circuitos.
Imagine que um determinado programa precisa utilizar 4 somas
simultaneamente. Numa mquina superescalar ou VLIW com 2 caminhos
seriam necessrios 2 ciclos de clock. Agora, poderamos reconhecer a
caracterstica do software e, durante a execuo do mesmo, construirmos
dinamicamente 4 somadores em paralelo, o que nos permitiria em um nico
cliclo de clock realizar as 4 operaes. A reconfigurao uma nova
abordagem que deseja trazer para o hardware a flexibilidade do software.
Bem, os campos de pesquisa em hardware so muitos e certamente o
leitor pode se interessar por algum em particular. A Internet nos ajuda
197
198
sobremaneira a encontrar temas de pesquisa, principalmente depois do

advento das bibliotecas digitais da ACM e IEEE.
Espero ter contribudo para a formao e informao do leitor com este
texto. Bom trabalho a todos os leitores!
Apndice A
Caches Revisitadas
A.1 Introduo
J estudamos os principais conceitos envolvidos na idealizao das
memrias cache, entretanto, no cobrimos por completo o assunto. Para ajudar
num entendimento mais completo dispomos neste apndice de uma
abordagem mais avanada, principalmente sobre os aspectos de caches writeback e como se d a escrita de dados.
J sabemos que a escrita numa cache write-back pode trazer algumas
dificuldades de inconsistncia de dados com o nvel inferior da hierarquia de
memria (por simplificao adotamos a memria principal, MP). Para resolver
o problema de inconsistncia necessrio que sempre que formos substituir
uma linha da cache por outra vinda da memria principal gravemos antes os
dados da linha que ser retirada da cache na memria principal. Isto faz com
que qualquer falha de escrita na cache em uma linha vlida gere um conjunto
de escritas na memria principal.
Uma forma mais eficiente de solucionar o problema acrescentar ao
campo de tag mais um bit, chamado bit de sujeira, ou dirty bit. Este bit ser
sempre iniciado com 0, mas quando for realizada uma escrita na cache, pelo
processador, o valor do dirty bit deve ser posto em 1, significando que o
contedo da cache diferente do contedo da memria principal para aquele
bloco. Isto faz com que sempre que for necessrio substituir uma linha em que
este bit esteja em 0, no seja necessrio escrever a linha inteira na memria
principal. Por outro lado, se este bit estiver em 1, o contedo da linha inteira
precisa ser copiado na memria principal, antes de ser sobrescrito por outro
bloco. A Figura A.1 mostra o esquema de uma cache com o bit de sujeira (d)
anexado s tags.
199
200
Endereo
Acerto (Hit)
dv
Informao
Solicitada
31 30 ..................14 13 ...........4...3. 2 1 0
2 bits
18 bits
tag
informaes
Way 1
10 bits
0
1
...
...
...
...
...
1022
...
...
...
...
...
...
1023
conjunto
MUX
MUX
codificador
2nn
Way 0
MUX
Figura A.1: Memria cache associativa por conjuntos do MIPS

com bits de validade e sujeira
A.2 Falha na Escrita

Outra possibilidade de ocorrncias na cache quando uma falha ocorre
durante uma escrita. Neste caso existem duas polticas predominantes:
- write allocate; e
- no write allocate.
No caso de cache que implementam a poltica write allocate, quando
ocorre falha numa escrita, o bloco trazido da memria principal para cache e
s ento trabalhado, como se houvesse acontecido um acerto (depende, a
partir deste ponto, da cache ser write-back ou write-through).
No caso de no write allocate, o dado que falhou na cache escrito
unicamente na memria principal, sem que o bloco seja trazido para cache.
Assim sendo podemos montar um fluxograma mostrando as principais
aes que ocorrem em cada possvel situao de acesso cache variando as
polticas implementadas. A Figura A.2 mostra este fluxograma. No esto
mostrados os detalhes da poltica de troca de linhas, nem como os blocos so
achados em uma cache, conhecimento presumido para quem l este apndice.
WRITE BACK
1. Escreve bloco da
cache na MP
DIRTYBIT = 1
1. Entrega dado ao
Processador
HIT
1. Carrega novo
bloco da MP na
cache
2. Entrega dado ao
Processador
3. DirtyBit = 0
DIRTYBIT = 0
1. Escreve dado na cache

2. DirtyBit=1
WRITE BACK
WRITE THROUGH
WRITE THROUGH
1. Transfere bloco da
MP para cache
WRITE
ALLOCATE
1. Escreve dado na cache

2. Escreve dado na MP
3. DirtyBit=0
HIT
ESCRITA
Figura A.2: Fluxograma simplificado de aes na cache
MISS
LEITURA
ACESSO
MISS
1. Escreve dado na MP
NO WRITE
ALLOCATE
Apndice A
201

Arquiteturadepc

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Arquiteturadepc

Загружено:

Авторское право:

Доступные форматы

PRESIDENTE DA REPBLICA

LUS INCIO LULA DA SILVA

Eduardo Brulio Wanderley Netto

Arquitetura de Computadores: A viso do software

Arquitetura de Computadores: a viso do software

Arquitetura de Computadores: a viso do software

sistemas digitais, o que nem sempre est presente em cursos de graduao

1.4 Aspectos Pedaggicos

Arquitetura de Computadores: a viso do software

Em um outro flanco esto os alunos do Ncleo de Pesquisas em

1.7 Bibliografia Especfica

Captulo 2: Linguagem de Montagem ___________________ 19

Captulo 3: Linguagem de Mquina_____________________ 67

Arquitetura de Computadores: a viso do software

Captulo 4: O Processador ____________________________ 97

Captulo 5: Desempenho do Computador _______________ 117

Captulo 6: Sistema de Memrias______________________ 129

Captulo 7: Entrada e Sada __________________________ 179

Captulo 8: Concluses ______________________________ 193

Apndice A: Caches Revisitadas_______________________ 199

Arquitetura de Computadores: a viso do software

Arquitetura de Computadores: a viso do software

Figura 1.1: Abstrao do Projeto de Hardware

Os softwares esto organizados, em relao ao hardware, quanto a sua

Arquitetura de Computadores: a viso do software

Figura 1.2: Camadas de Softwares

representao de dados diferente do nosso alfabeto convencional. Um

Do ponto de vista prtico, esta uma programao praticamente

Arquitetura de Computadores: a viso do software

A linguagem de alto nvel normalmente independente da mquina

Figura 1.3: Compilao e Montagem de um cdigo em HLL

1.2 Componentes de um Computador

Figura 1.4: Componentes de um Computador

Arquitetura de Computadores: a viso do software

A Figura 1.4 apresenta os componentes de um computador, mas possui

transferncia de uma prateleira inteira da memria para o banco de

Arquitetura de Computadores: a viso do software

Embora seja ruim em termos de vendas, o supermercado pode, a bem da

1.3 A viso do software

Dentro deste esprito, vamos definir o termo Arquitetura de

O Sistema Operacional o software bsico de maior importncia

1.3.1 O Sistema Operacional

Arquitetura de Computadores: a viso do software

Uma das principais caractersticas dos sistemas operacionais sua

1.3.2 Outros Softwares Bsicos

uma seqncia de linhas de cdigo em assembly, assim programar em alto

Arquitetura de Computadores: a viso do software

for (i=0; i<10; i++){

Figura 1.5: Esquema do Compilador/Montador/Ligador/Carregador

Na ligao apresentada anteriormente, chamada esttica, todo o

natural com as DLLs que o tempo de ligao transferido para dentro do

1.3.3 A Mquina Virtual Java

O sucesso de uma mquina virtual s pode ser alcanado se existirem

Figura 1.6: Compilao de um cdigo em Java

Arquitetura de Computadores: a viso do software

componentes do processo de criao e execuo de um software em Java. O

Figura 1.7: Mquina Virtual Java com JIT

Arquitetura de Computadores, que envolve o conhecimento mnimo de

1.5 Prtica com Simuladores

Pesquise na web e produza um resumo sobre Firmware.

Arquitetura de Computadores: a viso do software

Pesquise na web e produza um resumo sobre Mquina Virtuais.

1.7 Referncias Bibliogrficas Especficas