Você está na página 1de 41

MARIE

Trabalho desenvolvido pelos alunos do curso de


Sistemas de Informao (2011) da Universidade Federal
de Itajub UNIFEI.

SUMRIO
PARTE I: ENTENDENDO O MARIE
Foco em explicar o funcionamento do Computador simplificado Marie.
O QUE O MARIE?
POR QUE ESTUDAR O MARIE?

3
3

ARQUITETURA DE VON NEUMAN: Descrio breve da estrutura que se


baseiam os computadores atuais.
GARGALO DE VON NEUMAN: Problema da estrutura de Von Neuman.

COMPONENTES DO MARIE: Explicao dos componentes do Marie tendo


como suporte o infogrfico criado pelo Dr. Cludio Kirner.

O QUE ACONTECE QUANDO O MARIE LIGADO?


Sequncia de passos que o Marie submetido para executar programas.

ENDEREAMENTO NO MARIE: Componentes e tamanho de uma instruo e


mneumnicos.
MODOS DE ENDEREAMENTO: Endereamento direto e indireto.
DIAGRAMAS DE ENDEREAMENTO DE INSTRUES: Endereamento
direto e indireto.
TIPOS DE INSTRUES: Descrio dos tipos de instrues no Marie

8
9
12

PARTE II: PROGRAMANDO NO MARIE


Foco na construo de uma base que permita construir programas para o Computador
Simplificado Marie.
LINHAS E COMENTRIOS: Incio do programa, como fazer comentrios no cdigo.

13

DIRETIVAS: Org, Hex, Dec e ASCII - Conceitos importantes em programao no Marie.

13

ABSOLUTO E REALOCVEL: Mtodos de Programao.

15

TRADUO DE NVEL 1 E 2: Entendendo programas absolutos e realocveis.

16

MACRO INSTRUES: Conceito.

16

PARTE III: BIBLIOTECA DE PROGRAMAS


Macro Instrues e programas complexos comentados.
Hello World
Multiplicao
Diviso
Exponenciao
Raiz Quadrada
Ordenao pelo Mtodo da Bolha

17
17
18
21
24
25

PARTE IV: REFERNCIAS, ANEXO A e ALUNOS


ANEXO A: Como usar o simulador Marie

29

ALUNOS RESPONSVEIS PELO PROJETO.

39

REFERNCIAS BIBLIOGRFICAS

40

PARTE I: ENTENDENDO O MARIE


O que o Marie?
O computador simplificado MARIE simula um ambiente de uma
mquina com a arquitetura baseado na proposta por Von Neumann. Entretanto, contrrio aos
computadores atuais, suas instrues fazem referncia apenas um endereo de memria.
Tornando-o mais simples porm, com recursos limitados.
Por que estudar o Marie?
O MARIE tem uma arquitetura simplificada e um simulador didtico, prprio para ensino e
aprendizagem. Conhecendo o funcionamento dele torna-se mais fcil o entendimento de um
computador atual.

ARQUITETURA DE VON NEUMAN


A Arquitetura de von Neuman se baseia na arquitetura de computadores onde os programas
de uma mquina digital so armazenados no mesmo espao onde tambm so armazenados
os dados. Em outras palavras, esse conceito envolve o armazenamento de instrues e dados
na unidade de memria. Alm disso, caracterizado pela separao do processamento e
memria.
Nesse modelo de arquitetura, existem hardwares de entrada e sada de dados, uma CPU
(Central nica de Processamento), uma ALU (Unidade Lgica Aritmtica) que executa
operaes matemticas simples, uma unidade de controle que determina a sequencia de
instrues que sero executadas por meio de sinais.

GARGALO DE VON NEUMAN


Considere, nos computadores baseados na arquitetura de Von Neumann os seguintes
componentes:
- Unidade de processamento Central (CPU)
- Memria
A memria na maioria dos computadores armazena programas e dados simultaneamente
e possui uma taxa de transferncia menor do que a taxa de transferncia da CPU.
O fato de instrues e dados utilizarem o mesmo caminho para serem transferidos da
memria principal para a CPU limita a mquina a ficar aguardando que um dado chegue
para poder executar uma prxima instruo.
Da, surge-se a expresso Gargalo de Von Neumann, que nada mais , do que o
enfileramento de instrues e dados que s podem caminhar entre os componentes
citados acima um por um. Esse processo reduz a velocidade de operao e se agrava cada
vez mais que as memrias de computadores atingem tamanhos maiores.
]

COMPONENTES DO MARIE
Abaixo ser descrito graficamente os componentes do Marie de acordo com o modelo
elaborado pelo professor Cludio Kirner (Figura 1).

Figura1: Modelo do computador simplificado Marie.

Unidade Lgica Aritmtica (ALU): A ULA executa as principais operaes lgicas e aritmticas
do computador. Ela soma, subtrai, divide, determina se um nmero positivo ou negativo ou
se zero. Alm de executar funes aritmticas, uma ULA deve ser capaz de determinar se
uma quantidade menor ou maior que outra e quando quantidades so iguais. A ULA pode
executar funes lgicas com letras e com nmeros.
Registrador de instrues (IR): detm a prxima instruo a ser executada no programa.
Contador de Programa (PC): detm o prximo endereo de intruo a ser executado no
programa.
Registrador de entrada (InREG): Armazena os dados inseridos pelos componentes de entrada
(ex. teclado).

Registrador de sada (OutREG): Armazena os dados que sero enviados aos componentes de
sada (ex. monitor).
Registrador de endereo de memria (MAR): especifica um endereo de memria para a
prxima leitura ou escrita.
Registrador de Buffer de Memria (MBR): contm dados a serem escritos na memria ou
recebe dados lidos da memria.
Acumulador (ACC): Responsvel por guardar registros de dados. Este um registo de uso
geral e mantm os dados que a CPU precisa processar. A maioria dos computadores
atualmente possuem mltiplos desses registos de uso geral.
Memria ou memria principal (MEM): responsvel pelo armazenamento temporrio de
instrues e dados.
C: Controlador responsvel por gerenciar o funcionamento dos demais componentes do
modelo de computador simplificado apresentado.
Linha Azul: Ciclo de busca de Dados
Linha Vermelha: Ciclo de busca de Instruo
O funcionamento do Marie consiste basicamente na busca por dados e instrues. Esse
processo ser abordado a seguir.

O QUE ACONTECE QUANDO O MARIE LIGADO?


INCIO

O contador calcula
o endereo da
instruo.

Busca a prxima instruo.


Caso no haja novas
instrues, o computador
fica ocioso.

Busca essa instruo


na memria.

Retorna, no caso de cadeia


de caracteres ou vetor, e
continua trabalhando, s
que agora com o prximo
elemento.

Depois de ter calculado o(s)


endereo(s) de destino
/so armazenado(s) o(s)
resultado(s).

H a decodificao da
operao da instruo
(add, load, store, etc.).
Ou seja, o computador
identifica o que ele ter
que fazer.

Depois de identificar o
que tem que fazer
calculado o endereo do
operando envolvido na
operao.

Faz as devidas operaes


sobre os dados que ele
buscou na memria.
Ocorre a busca do
operando na memria. Se
for mais de um dado ele
retorna ao passo anterior
para buscar todos os dados
necessrios para executar
a operao.

Depois de cada operao


ter sido executada
calculado o endereo de
destino desses resultados,
que podem ser muitos.

ENDEREAMENTO NO MARIE
Para explicar melhor os modos de endereamento, ser brevemente descrito instrues em
linguagem de mquina.
Cada instruo deve conter o necessrio para que a CPU consiga execut-la. Ela composta
por 4 elementos:

Cdigo de operao
Referncia a um operando de entrada
Referncia de sada
Endereo da prxima instruo

As instrues possuem 16 bits.


4 bits

12 bits

No Marie, o cdigo de operao ocupa os 4 primeiros bits. Estes bits so representados por
mnemnicos. Sendo estes:

A referncia ao operando de entrada o valor a que se deseja operar ou o endereo que


indique onde esse valor est. Corresponde aos prximos 12 bits.
A referncia de sada (ou referncia ao operando destino) implcita, no caso do Marie o
Acumulador (ACC Registrador temporrio). Desta maneira a memria no utilizada.

Da mesma forma o endereo da prxima instruo tambm implcito, normalmente a


prxima linha de cdigo, isto , prximo valor do contador. A menos que algumas instrues
desviem pra outra parte do cdigo (skipcond e jump).
MODOS DE ENDEREAMENTO
Existem 2 tipos de endereamento no Marie:

Endereamento Direto

No modo de endereamento direto, o endereo eficaz do operando dado no campo de


endereo da instruo. A vantagem desse endereamento que necessrio apenas um nico
acesso memria na busca do operando, e tambm no h necessidade de clculos adicionais
para encontrar o endereo efetivo. A desvantagem que o tamanho do nmero limitado ao
tamanho do endereo.

Ex: ADD A
- Procura pelo operando na posio A da memria
- Adiciona o contedo ao acumulador.

Endereamento Indireto

No modo de endereamento indireto, o campo de endereo desta vez aponta para uma
posio da memria que aponta o endereo do operando. A vantagem desse endereamento
que para o comprimento de uma palavra N, um espao de endereo de 2n (dois elevado n)
pode ser dirigido. A desvantagem, que a execuo acaba sendo mais lenta.

Ex: ADD A
-Busca em A, encontra o endereo do operando (como exemplo, B), busca em B pelo
operando.
-Adiciona o contedo ao acumulador.

Obs.:
O Marie no possui endereamento Imediato, pois seu programa sempre precisar
acessar a memria.

Ex: ADD 5.
Apesar de parecer que o valor cinco ser atribudo no acumulador, est errado.
O Marie buscar na linha 5 da memria o valor, somar ele e colocar no ACC, sendo
portanto, endereamento Direto.

DIAGRAMAS DE ENDEREAMENTO DIRETO DAS INSTRUES NO MARIE

Instruo: Add x
0011

Memria

Endereo x

Operando

Acumulador

Instruo: Store x
0110

Endereo x

Memria

x
Acumulador

Operando

Instruo: Load x
0001

Endereo x

Memria

Operando

Operando

Acumulador

Instruo: Subt x
0100

Endereo x

Memria

Operando
Acumulador

Instruo: Input
0101
InReg
(Entrada de dados
atravs de
perifricos.)

Acumulador

Operando

10

Instruo: Output
OutReg

0101

(Sada de dados
para perifricos.)

Acumulador

Operando

DIAGRAMAS DE ENDEREAMENTO INDIRETO DAS INSTRUES NO MARIE

Instruo: ADDi x
1100

Memria

Endereo x

Endereo do Operando

Operando
Acumulador

Memria

Instruo: Jns x
1100

Endereo x

End. do espao que contem o operando

Subrotina
Operando

Acumulador

11

TIPOS DE INSTRUES

Processamento de dados: Instrues aritmticas e lgicas.


-Instrues aritmticas fornecem a capacidade computacional para processamento de dados
numricos.
-Instrues lgicas (booleanas) operam sobre bits de uma palavra, como bits e no como
nmeros.

Armazenamento de dados: Instrues de memria.


-Instrues de memria move dados entre a memria e os registradores.

Movimentao de dados: Instrues de E/S (entrada, sada).

Controle: Instrues de teste e desvio.


-Instrues de teste so usadas para testar o valor de uma palavra de dados ou o
estado de uma computao.
-Instrues de desvio so utilizadas para desviar a execuo do programa para uma nova
instruo.

12

PARTE II: PROGRAMANDO NO MARIE


Para se programar no Marie, primeiramente devem-se considerar os seguintes pontos:

No Anexo A, est descrito como usar o Simulador;


O programa automaticamente se inicia na linha 0 (zero). Essas linhas so implcitas;
Para adicionar comentrios dentro do programa basta inici-lo com / ou //. Ou ainda
/*... */. No contado como linha do programa;
Instrues :
o Load <endereo> carrega valor contido no endereo no ACC Acumulador
(Registrador)
o Store <endereo> armazena valor do ACC no endereo
o Add <endereo> - Soma o valor do endereo ao ACC
o Subt <endereo> Subtrai o valor do endereo no ACC
o Input Carrega no ACC um valor disponibilizado pelo usurio
o Output Mostra ao usurio o valor contido no ACC
o Halt Para o programa
o Skipcond [000 || 400 || 800] Instruo de teste. Se uma condio
verdadeira o programa salta 2 linhas de cdigo, seno ela segue
normalmente.
Skipcond 000 Avalia se o ACC menor que zero
Skipcond 400 Avalia se o ACC igual a zero
Skipcond 800 Avalia se o ACC maior que zero
o Jump <endereo> Salta para linha do cdigo determinada
o Jns <endereo> Salta para subrotina iniciada no endereo
o Clear Zera o ACC
o Addi <endereo> Soma ao ACC o valor que gerado num determinado
trecho do cdigo
o Jumpi <endereo> - Pula para um linha depois do endereo referenciado
Diretivas:
- Caso deseje-se que o programa comece numa linha determinada pelo
usurio, usa-se a funo org no comeo do programa, como exemplificado na figura 2:
Sem org

Com org = 100

Figura 2: Cdigo com nfase nas linhas


13

- No fim do cdigo, sempre necessrio inicializar todos os endereos


usados no programa, caso contrrio no ser possvel usar o espao de memria
desejado. Como na figura 3:

Figura 3: Inicializao de espao de memria.


A forma de inicializao do espao de memria pode ser:
-Decimal: Dec <valor numrico inicial>
- Hexadecimal: Hex <valor numrico inicial>
- ASCII: Dec <cdigo correspondente em ASCII>

Nos programas do Marie o cdigo do programa e os dados usados so distribudos na memria


de forma sequencial. Por utilizar a linguagem Assembler o Marie no separa programas e os
dados na memria, por isso os programas acessam um espao de memria para pegar um
valor desejado. De forma abstrata, se assemelha figura 4:
Programa
Programa
Programa
Programa
Dado

Dado
Dado

0
1
2
3
4
5
...
n

Figura 4: Imagem simblica da memria.


Decorrente dessa forma de distribuio na memria existe dois tipos de programas no Marie:
ABSOLUTO e REALOCVEL.

14

ABSOLUTO
Programas absolutos so programas estticos em que os valores so acessados atravs de um
endereo direto da memria.
Exemplo de programa absoluto:

0
1
2
3
4
5
6
7
8
9

O programa armazenar os valores do usurio diretamente no espao


solicitado. Quando ocorrido, os espaos so atualizados para esses valores.

Espaos de memria inicializados para guardar nmeros decimais.

REALOCVEL
No formato realocvel no necessrio citar o endereo da memria onde os dados esto ou
devero ser gravados, basta referenci-lo com variveis que apontaro para o endereo. O
contador de programa percorrer o algoritmo at encontrar tal varivel que, no caso do
MARIE, dever ser declarada no final do programa. Neste formato a programao se torna
mais simples.
Exemplo de programa realocvel:

0
1
2
3
4
5
6
7
8
9

O programa armazenar os valores do usurio no espao em que varivel x/y esto


marcando. Quando ocorrido, os espaos so atualizados para esses valores.

Espaos de memria inicializados para guardar nmeros decimais, marcados com a


varivel x/y. Sempre que as referncias x e y forem usadas no programa,
mencionaro esse espao de memria (linha 8 e 9, no caso).

15

TRADUO DE NVEL 1 E 2
O conceito de traduo de nvel 1 e 2 consiste em quantas vezes necessrio fazer a leitura do
programa. Quando o programa absoluto precisa-se fazer apenas uma leitura e quando
realocvel preciso fazer duas.
1 Leitura:
0
1
2
3
4
5
6
7
8
9

Durante a 1 leitura, criada uma Tabela de Smbolos:

Em seguida, esses smbolos so substitudos pelos valores


correspondentes para a segunda leitura.

2 Leitura:
0
1
2
3
4
5
6
7
8
9

Na segunda leitura o
programa j est apto para
ser executado.
MACRO INSTRUES
Uma macro-instruo um sinnimo para um grupo de instrues que pode ser usado como
uma instruo ao longo do cdigo-fonte. O uso de macros facilita a especificao de trechos
repetitivos de cdigo, que podem ser invocados pelo programador como um nica linha no
programa. Por esse motivo, diversos montadores apresentam extenses com funcionalidades
para a definio e utilizao de macros.
A seguir, seguem alguns cdigos e macro instrues.
16

PARTE III: BIBLIOTECA DE PROGRAMAS


Hello World
a,

um,
x,

stop,

clear
load x
subt stop
skipcond 000
halt
clear
addi x
output
load x
add
um
store x
clear
jump a
hex
hex
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
dec
hex

1
00F
72
101
108
108
111
0
87
111
114
108
100
0
33
33
33
01E

Multiplicao
//Programa que realiza uma multiplicao de nmeros inteiros atravs de somas sucessivas
input
//pede um valor de entrada
store x
//guarda em x
output
//imprime na tela o valor digitado
input
store y
output
//verificao de valor zero
skipcond 400 //testa de y igual a zero
jump tx
//se condio falsa, testa varivel x
z,
load zero
17

output
halt
tx,
load x
skipcond 400
jump teste2 //se condio falsa, pula para o calculo
jump z
//verificao de negativo
teste2, load x
store px
skipcond 000 //testa se valor x negativo
jump ty
//se x for positivo, testa y
load x
//subtraes sucessivas para inverter o sinal da variavel
subt x
subt x
store x
ty,
load y
store py
skipcond 000
jump calc
//caso ambas os valores forem positivos, pula para calc
load y
subt y
subt y
store y
//calculo
calc, load y
store i
//atribui o valor de y ao contador i
load x
subt y
//subtrao para identificar o maior valor
skipcond 000 //testa se a subtrao menor que zero
jump loop //se condio falsa, pula para loop de soma
jump troca //se condio verdadeira, pula para funo troca
troca, load x
store i
jump loop2
//multiplicao
loop, load r
add
x
store r
load i
subt decr
store i
skipcond 400
jump loop
jump fim
loop2, load
add
store
load
subt
store

//o contador passa a ser o menor valor

//carrega resultado
//soma x
//carrega o contador i
//decrementa o contador
//testa se contador igual a zero
//se condio falsa, volta ao comeo do loop
//se condio verdadeira, pula para fim

r
y
r
i
decr
i
18

skipcond 400
jump loop2
jump fim
fim,

load px
skipcond 000
jump pos1 // verifica o sinal original de x para comparar com o sinal de y
jump neg1
pos1, load py
skipcond 000
jump result1 // se x > 0 e y > 0, imprime o resultado positivo
jump result2 // se x > 0 e y < 0, imprime o resultado negativo
neg1, load py
skipcond 000
jump result2 //se x < 0 e y > 0, imprime o resultado negativo
jump result1 //se x < 0 e y < 0, imprime o resultado positivo
result1, load r
//carrega o resultado
output
//imprime resultado
halt
//para
result2, load zero
subt r
output
halt
//declarao de variveis
x,
dec
0
//entrada x
y,
dec
0
//entrada y
r,
dec
0
//resultado
i,
dec
0
//contador
decr, dec
1
//decrementa
zero, dec
0
px,
dec
0
//variavel auxiliar para valor original de x
py,
dec
0
//variavel auxiliar para valor original de y

Diviso
input
//Carrega o valor do dividendo digitado no acumulador.
store num
//Armazena valor do acumulador na memria num.
input
//Carrega o valor do divisor digitado no acumulador.
skipcond 400
//Verifica se o valor do acumulador zero.
jump init
//Caso valor do acumulador seja diferente de 0, vai para init.
jump FimErro
//Caso valor do acumulador seja igual a 0, finaliza.
//**Init:inicia as operaes.
init,
store den
//Armazena valor do acumulador na memria den.
load den
//Carrega o valor do divisor na memria den.
store cont
//Armazena o valor do divisor em uma memria auxiliar cont.
load num
//Carrega o valor do dividendo na memria num.
store aux
//Armazena o valor do dividendo em uma memria auxiliar aux.
19

jns
sinal //Verifica os sinal do divisor e do dividendo.
load aux
//Carrega o valor do mdulo do divisor no acumulador.
subt cont
//Subtrai do acumulador o valor do mdulo do divisor.
skipcond 000
//Verifica se o acumulador menor do que zero.
jump se0
//Caso o valor do acumulador seja maior ou igual a zero continua.
jump fim0
//Caso o valor do acumulador seja menor que 0 finaliza com o valor 0.
//**Se0 Veririfca o valor do acumluador para tomar a decisao de qual sera a proxima
instruo.
se0,
skipcond 400
//Verifica se o valor do acumulador zero.
jump loop
//Caso valor do acumulador seja diferente de zero vai para o loop.
jump fim1
//Caso valor do acumulador seja igual a zero finaliza com o valor 1.
//**Loop subtrai do divendo o valor do divisor e guarda o novo valor no divisor, at o
dividendo se tornar menor ou igual a zero,e para cada vez que feito o processo aumenta em
um o valor de div.
loop, load aux
//Carrega o valor da memria aux no acumulador.
skipcond 800
//Verifica se acumulador maior do que zero.
jump fim2
//Caso o valor do acumulador seja menor ou igual a zero v para fim2.
load div
//Caso o valor do acumulador seja maior do que zero carrega o valor de
div no mesmo.
add
um
//Adiciona ao acumlador o valor um.
store div
//Armazena o valor do acumulador na memria div.
load aux
//Carrega o valor da memria aux no acumulador.
subt cont
//Subtrai do acumulador o valor da memria cont.
store aux
//Armazena o valor do acuumulador na memria aux.
jump loop
//Vai para loop.
//**Sinal:Caso o valor do divisou ou dividendo sejam negativos, trasnforma os valores
negativos em positivos.Caso sejam positivos, os mantm como esto.
sinal, load aux
//Carrega o valor da memria auxiliar aux no acumulador.
skipcond 000
//Verifica se o valor do acumulador menor do que zero.
jump vercont //Caso acumluador seja maior ou igual a zero,vai para vercont.
load aux
//Carrega o valor da memria auxiliar aux no acumulador .
subt aux
//Subtrai do acumulador o valor da memria auxiliar aux(dividendo).
subt
aux
//Subtrai do acumulador o valor da memria auxiliar aux(dividendo).
store aux
//Armazena o valor do acumulador(mdulo do dividendo) na memria
auxiliar aux.
vercont, load cont
//Carrega o valor da memoria auxiliar cont no acumulador.
skipcond 000
//Verifica se o acumaldor menor do que zero.
jumpi sinal //Caso o valor do acumulador seja maior ou igual a 0 va para jsn
passando por sinal.
load cont
//Carrega o valor da memria auxiliar cont no acumulador.
subt cont
//Subtrai do acumulador o valor da memria auxiliar cont(divisor).
subt cont
//Subtrai do acumulador o valor da memria auxiliar cont(divisor).
store cont
//Armazena o valor do acumulador(mdulo do divisor) na memria
auxiliar cont.
jumpi sinal //Va para jns passando por sinal.
//**Fim0:Finalizaza com o valor 0, mdulo do divisor maior do que o mdulo do dividendo.
fim0, load zero
//Carrega o valor 0 no acumulador.
output
//Mostra o valor do acumulador na tela.
halt
//Finaliza.
//Fim1:Finaliza com o valor 1,dividendo e divisor iguais.
fim1, load um
//Carrega o valor 1 no acumulador.
output
//Mostra o valor do acumulador na tela.
20

halt
//Finaliza.
//**Fim2:Finaliza com o valor do quancionte,mdulo do divisor menor do que o mdulo do
dividendo.
fim2, load num
//Carrega o valor da memria num no acumulador.
skipcond 800
//Verifica se o valor do acumulador maior do que zero.
jump a
//Caso o valor do acumularo seja menor do que zero va para a.
jump b
//Caso o valor do acumularo seja maior do que zero va para b.
//**a:Caso dividendo negativo e divisor positivo, retorna quociente negativo.Caso dividendo
negativo e divisor negativo, retorna quociente positivo.
a,
load den
//Carrega o valor da memria den no acumulador.
skipcond 800
//Verifica se o valor do acumulador maior do que zero.
jump positivo //Caso o valor do acumularo seja menor do que zero va para positivo.
jump negativo //Caso o valor do acumularo seja maior do que zero va para
negativo.
//**b:Caso dividendo positivo e divisor positivo, retorna quociente positivo.Caso dividendo
positivo e divisor negativo, retorna quociente negativo.
b,
load den
//Carrega o valor da memria den no acumulador.
skipcond 800
//Verifica se o valor do acumulador maior do que zero.
jump negativo //Caso o valor do acumularo seja menor do que zero va para
negativo.
jump positivo //Caso o valor do acumularo seja maior do que zero va para positivo.
//**Negativo:finaliza com quociente negativo.
negativo, load zero
//Carrega o valor zero no acumulador.
subt div
//Subtrai o valor de div do acumulador.
output
//Mostra na tela o valor do acumulador(valor negativo de div).
halt
//Finaliza.
//**Positivo:finaliza com quociente positivo.
positivo, load div
//Carrega o valor de div no acumulador.
output
//Mostra na tela o valor do acumulador(valor de div).
halt
//Finaliza.
//**FimErro:Caso divisor igual a zero, retorna erro.
FimErro, load erro
//Carrega mensagem no acumulador.
output
//Mostra valor do acumulador.
load erro2
output
load erro2
output
load erro3
output
halt
//Finaliza.
num, dec
0
//Memria reservada para o dividendo.
den, dec
0
//Memria reservada para o divisor.
aux,
dec
0
//Memria auxiliar para manipular o dividendo.
cont, dec
0
//Memria auxiliar para manipular o divisor.
um,
dec
1
//Memria de um.
div,
dec
0
//Memria para guardar o valor do quociente da diviso.
zero, dec
0
//Memria de zero.
erro, dec 69
//Mensagem erro.
erro2, dec 82
//Continuaao mensagem erro.
erro3, dec 79
//Continuaao mensagem.Para ver mensagem selecione ascii em output
21

Exponenciao
Input
/libera entrada de dados
Store B /guarda o valor de x
Input
/libera entrada de dados
Store E /guarda o valor de Y
store C
/ /testa expoente zero
load E
/carrega o valor do expoente
skipcond 400 / se =0 ja pula p/fim prog
jump teste9 /senao continua
jump halt0
/testa expoente negativo
teste9, load E
/carrega o valor do expoente
skipcond 000 / se =0 ja pula p/fim prog
jump teste1 /senao continua
jump halt
/teste expoente 1
teste1, load E
/carrega o valor do expoente
subt hum
skipcond 400 / se =0 ja pula p/fim prog
jump teste2 /senao continua
jump halt9
/teste valor base zero
teste2, Load B
/carrega o valor de x
skipcond 400 /se B for zero executa jump halt, senao jump um
jump teste3
jump halt
/teste base um
teste3, Load B
/carrega o valor de x
subt hum
skipcond 400 /se X for zero executa jump halt, senao jump um
jump sin
jump halt0
/testa valor negativo de X
sin, load B
skipcond 000
jump loop
load zero
subt B
store B
load sinal1
add hum
store sinal1

22

loop, load R /carrega a variavel R


store Y / grava o valor de R em Y
load B /carrega vlor base
store X / grava em x

/testa valor 1
calc, load Y
/carrega o valor de Y
subt hum / subtrai 1 de y
skipcond 400 / se y-1=0 ja imprime o valor de X senao faz multiplicaao
jump tres
jump quatro
quatro, load X
store R
jump halt1
tres, load X / carrega X
store Z / carrega o valor de x em z
cinco, load X / carrega x
add Z /adiciona z
store X / salva o valor da soma em x
load cont / carrega contador
add hum /adiciona 1 no contador
store cont / salva o valor da soma no contador
load Y /carrega o valor de y
subt cont / subtrai contador de y
skipcond 400 / se y-cont=0 fim da mult(jump quatro) senao faz jump cinco
jump cinco
jump quatro
halt, load zero
output
halt
halt0, load hum
output
halt
halt9, load B
output
halt
halt1, load hum
store cont
load E
subt hum
store E
load E
skipcond 400
jump loop
23

load sinal1
subt hum
skipcond 400
jump saida
dnew, load C
subt l2
store C
skipcond 400
jump mais
jump saida
mais, load C
skipcond 000
jump dnew
load zero
subt X
store R
jump saida

saida, load R
output
load zero
store cont
load cont
add hum
store cont
load zero
store X
store Y
store Z
store sinal1
store sinal1
load hum
store R
halt
X,
Dec
0
Y,
Dec
0
Z, Dec 0
zero, Dec 0
hum, Dec 1
cont, Dec 1
conts, Dec 0
sinal1, Dec 0
l2, Dec 2
conty, Dec 0
E, Dec 0
B, Dec 0
R, Dec 1
C, Dec 0
24

Raiz quadrada
// Algoritmo de resolucao de quadrados perfeitos pelo metodo de JONOFON
//
//
O resultado apresentado na forma do menor quadrado perfeito
// cuja resposta seja maior que o numero apresentado e em seguida o valor
// a ser subtraido deste quadrado perfeito para que a resposta seja
// encontrada, se o quadrado for perfeito o segundo numero nao sera
// mostrado.
Org
Reini, Clear
Input
Store
Teste1, Skipcond
Jump
Jump
Teste2, Skipcond
programa
Jump

100

Inicio, Load
Subt
do 1
Store
Skipcond
Jump
Load
Add
Store
Load
Add
Store
Jump

Num
Sequ

Result, Load
Output
Load
Skipcond
Output
Load
Store
Load
Store
Store
Jump

Cont

// Carrega e imprime o resultado

Num
400

// Carrega o valor e verifica se zero

// Recebe a entrada do usuario


Num
400
// Verifica se o numero entrado um negativo
Teste2
Fim
// se for sai com um codigo de erro
800
// Verifica se o numero for um zero que o codigo para sair do
OErr

Num
800
Result
Cont
Um
Cont
Sequ
Dois
Sequ
Inicio

Zero
Num
Um
Cont
Sequ
Reini

// Carrega o numero inserido


// Subtrai dele a Sequencia de numeros impares comecando

// Verifica se o resultado menor que zero


// se for mostra o resultado
// senao incrementa o contador da resposta em 1

// e incrementa o numero impar na sequencia

// e volta ao inicio

// senao for imprime o valor


// se for limpa as variaveis e retorna ao inicio

OErr, Load
Err
// Escreve 9999 na tela como resposta ao erro de entrada de
um numero negativo e retorna ao inicio
Output
Jump
Reini
25

Fim,

Halt

Num,
Cont,
Zero,
Um,
Dois,
Sequ,
Err,

Dec
Dec
Dec
Dec
Dec
Dec
Dec

0
1
0
1
2
1
9999

Ordenao por bolha


Input /*So lidos, nesse trecho do cdigo, 5 valores, sendo cada um
store a
atribudo a uma varivel*/
input
store b
input
store c
input
store d
input
store e
/*Comeo da bolha*/
loop, load cont /*A varivel cont ser utilizada para fazer o loop quantas vezes
forem
skipcond 400 necessrias, o loop s ser feito se cont valer 0*/
jump end
/*Se cont for diferente de zero ele pula para END*/
load um
/*Nesse trecho, cont recebe o valor 1, toda vez que for feita uma troca
store cont nas variveis, cont receber 0 para entra novamente no loop*/
load a
subt b
skipcond 000
jump bc
load a
store aux
load b
store a
load aux
store b
jns
atc
jump bc

/*Se a - b < 0 significa que b > a*/


/*ento se b > a, ele pula uma linha e troca as variveis*/
/*se a > b, ele pula para BC e no meche nessas*/
/*
aux recebe a
a recebe b
b recebe aux */
/* pula para uma subrotina que faz cont valer 0
para fazer novamente o loop */

bc,
load b
/*Se a > b ele pula pra c, para fazer a mesma comparao s que
com
subt c
b e c */
skipcond 000
26

jump cd
load b
store aux
load c
store b
load aux
store c
jns
atc
jump cd

/*Observe que, toda vez que necessrio trocar, o cont recebe 0 */

cd,
load c
subt d
skipcond 000
jump de
load c
store aux
load d
store c
load aux
store d
jns
atc
jump de
de,
load
subt e
skipcond 000
jump loop
load d
store aux
load e
store d
load aux
store e
jns
atc
jump loop

d
/*Na comparao dos 2 ltimos observe que ele chama o loop
independente se trocou ou no, pois no comando na frente do
endereo loop ele faz um load cont, se o cont recebeu 0 durante
a execuo do programa quer dizer que houve troca, entao ele entra
no loop novamente, se cont for 1, significa que no houve troca, ou
seja, j estava ordenado*/

atc,
load
store
jumpi

cont /* a subrotina atc


faz cont valer 0 */

load
zero
cont
atc

end, load
skipcond 800
halt
subt um
store five
load zero
addi p
output

/* atc = pc(de onde foi chamada) + 1 */

five
/* a varivel five ser decrementada de 5 at 0*/
/*quando for 0 ele encerra o programa*/
/* five <= five -1*/
/*o addi ACC <= ACC + m[ m[ p ] ] (pega o valor de p e usa como
endereo) no caso, p = 04F, que o endereo da varivel a, ento,
27

load
add
store
jump

p
um
p
end

m[ m[ x ] ] == a, logo, addi p == ACC = ACC + a, depois, output */


/*somando +1 em p, faz ele acessar o dado seguinte, ou seja, b..c..d..*/
/*como a condio do skipcond five valer 0, o p vai ser incrementado
5 vezes, indo de a ate e e exibindo na tela*/

a,
b,
c,
d,
e,
aux,
um,
zero,
cont,
five,
p,

dec 0 /*04F*/
dec 0 /*050*/
dec 0 /*051*/
dec 0 /*052*/
dec 0 /*053*/
dec 0 /*utilizada para trocar os valores*/
dec 1 /*varivel com valor 1*/
dec 0 /*varivel com valor 0*/
dec 0 /*controle da ordenao*/
dec 5 /*Utilizada no fim para fazer um loop de 5 ate 1 */
hex 04F
/*endereo de a*/

28

PARTE IV:
ANEXO A: COMO USAR O SIMULADOR DO MARIE
1 - Instalando o Computador MARIE
O MARIE pode ser encontrado no site a seguir, como mostra a imagem:
http://computerscience.jbpub.com/ecoa/2e/student_resources.cfm

O software vem como um arquivo ZIP. Voc deve primeiro descompactar o arquivo
ZIP, como mostra a imagem a seguir.

29

Ao fazer isso, voc encontrar trs arquivos .jar (Arquivo JAVA), dois arquivos .doc
(Documentao completa e um rpido guia de iniciao), um arquivo README, e trs programas de
exemplo do MARIE. Tudo o que voc precisa fazer clicar duas vezes sobre o cone MarieSim.jar para
abrir o simulador MARIE, ou o arquivo MarieDP1.jar para abrir o simulador datapath.

Ao realizar esse processo, a janela principal do programa ir abrir.

30

2 - Janela Principal do Programa


2.1 Viso Geral

1 Menu Principal: o local onde se executam os comandos do MARIE, como, por exemplo, executar
um programa.
2 Lista de Instrues: quando um programa carregado, suas instrues so mostradas nesse local.
3 Indicadores: o local onde todos os valores do computador (Como acumulador, contador de
programas, etc) so mostrados. tambm o local onde so colocados os dados de entrada (Em INPUT).
4 Janela de Sada: seria como o monitor do computador MARIE, onde todos os dados de sada so
exibidos.
5 Memria: o local onde a memria do computador MARIE exibida, com seus respectivos valores.
2.2 Executando um Programa
Para executar um programa no MARIE (Este j dever estar compilado, no formato .MEX) devese primeiro carreg-lo, clicando na opo [File | Load] do Menu Principal. Caso voc tenha apenas feito
mudanas em um programa j aberto, basta usar a opo [File | Reload] para recarreg-lo. Caso voc
no o recarregue, as mudanas realizadas no tero efeito.

31

O simulador MARIE suporta diversos modos de execuo das instrues. Voc pode executar
uma instruo por vez usando a opo [Run | Set Step Mode | On], ou voc pode deixar do modo
padro para o computador executar o programa sem intervenes. Caso voc escolha a opo de
executar uma instruo por vez, voc deve usar o boto [Step] do menu principal para passar de uma
instruo para outra.

32

Por padro, o simulador do MARIE espera 10 milissegundos entre a execuo de cada


instruo. Voc pode aumentar esse valor para at 3000 milissegundos usando a opo [Run | Set
Delay], porm este valor no pode ser diminudo para menos de 10 milissegundos.

33

2.3 Input e Output


Tanto a janela de entrada (Input) quanto a de sada (Output) esto definidas, por padro, para
lerem e imprimirem valores de acordo com a tabela ASCII. Para mudar isso, basta clicar nos retngulos
com a respectiva opo, ao lado de cada janela, e escolher o mtodo de entrada ou sada desejado. O
mtodo de entrada pode ser diferente do de sada.

3.4 Opes de Breakpoint

34

O simulador MARIE suporta o processamento de breakpoints (ponto de interrupo) atravs do


uso de checkbox (caixas de seleo) associadas a cada instruo do programa. As checkboxes de
breakpoints so mostradas com as instrues do programa na janela de monitorao do simulador.
Voc pode selecionar ou desmarcar uma checkbox com um clique do mouse. As marcaes dizem ao
simulador para parar na instruo que est selecionada quando voc seleciona a opo [Breakpoints |
Run to Breakpoint] do menu.
Nota: Se voc especificar um breakpoint numa instruo Halt, a opo [Run to Breakpoint] ir
primeiro executar um Restart, reiniciando o programa, e ento execut-lo novamente desde o incio.
Para retirar todos os breakpoints do monitor, selecione a opo [Breakpoints | Reset Breakpoints] do
menu.

2.5 Opes Adicionais


O simulador Marie disponibiliza opes adicionais no menu para:
3.5.1 - Reiniciar o Simulador: [Run | Restart]
Redefine o contador do programa para o incio do programa. No deve ser confundido com a
opes de Reset.
3.5.2 - Redefinir o Simulador: [Run | Reset]
Limpa o sistema, assim como ao pressionar o boto Reset em um computador pessoal.
Devido limpeza que esta rotina realiza, uma confirmao ser solicitada antes que a redefinio seja
executada.
3.5.3 - Parar um programa: [Stop]
Este boto ser disponibilizado quando estiver um programa estiver em execuo, e utilizado
para parar esta execuo.

35

3.5.4 - Mostrar a tabela de smbolos: [Symbol Map]


Este boto mostra uma tabela de smbolos (variveis) para o programa que estiver em
execuo.

4 Janela de Edio de Cdigo do MARIE


Uma vez que voc selecione [File | Edit], e se voc no tiver um arquivo carregado no
simulador, o quadro editor exibido com uma rea de texto em branco. Se, no entanto, voc j
tiver carregado um arquivo montado no simulador, o cdigo fonte para que o arquivo carregue
automaticamente levado para o editor se o editor puder localiz-lo.
Os arquivos de cdigo fonte do MARIE devem ter um ". Mas" como extenso, por MARIE
Assembler. O editor s reconhece arquivos desse tipo. Depois de salvar um arquivo com
extenso ". Mas" , a opo de menu Assemble torna-se habilitada e voc pode montar o seu
programa, selecionando o menu de arquivo Montar atual escolha. Se voc carregar um j
existente ". Mas" arquivo, o boto Assemble ativado automaticamente. Todas as modificaes que
voc fez para o seu arquivo em linguagem assembly so salvos automaticamente pelo editor antes de
sua chamada para o assembler.

36

Se o montador detecta erros em seu programa, o editor envia uma mensagem e o arquivo de
listagem de montagem aparece em um quadro pop-up. Tudo o que voc precisa fazer corrigir o
seu programa e pressione o boto Assemble mais uma vez. Se o arquivo no contm outros
erros assembler, seu programa foi montado com sucesso. Se desejar, voc pode exibir ou imprimir
o arquivo de listagem de montagem, usando o editor ou qualquer outro programa de processamento de
texto.
O arquivo de listagem ser colocado no diretrio atualmente registrado, juntamente com o
cdigo do MARIE do arquivo, se a montagem foi bem sucedida. O arquivo de listagem um arquivo de
texto simples com um ". Lst" extenso. Por exemplo, quando X.mas montado, a
montadora produz X.lst. Voc pode visualiz-lo, imprimi-lo, ou incorpor-lo em outro documento como
faria com qualquer arquivo de texto puro. Se a montagem livre de erros, o ". Mex" ou MARIE arquivo
executvel tambm ser colocado no mesmo diretrio que a fonte e os arquivos da lista. Este um
arquivo binrio (na verdade um objeto serializado Java), que executado pelo simulador.

37

Por exemplo, se seu cdigo-fonte conjunto chamado MyProg.mas, o arquivo de listagem ser
chamado MyProg.lst e o executvel ser chamado MyProg.mex.
Depois de ter conseguido uma montagem "limpa" do seu programa, voc ver a mensagem
mostrada na figura a seguir. Se voc estiver satisfeito com o seu programa, voc pode sair do editor,
fechando sua janela ou selecionando a opo [File | Exit.]

Como indicado acima, o editor MARIE fornece apenas as mais bsicas funes de edio de
texto, mas adaptado ao ambiente MarieSim. O boto Ajuda fornece-lhe com alguma ajuda em geral,
bem como um conjunto de instrues "cheat sheet" que voc pode usar como referncia quando voc
escrever seus programas.
O quadro no qual o editor aparece pode parecer um pouco diferente no seu sistema, mas voc
pode manipul-lo como voc pode com qualquer quadro, ou seja: voc pode maximiz-lo, minimizlo, escond-lo ou fech-lo. Isto verdade para todos os quadros gerados pelo editor, sendo essa a
forma como ele responde aos seus comandos.

38

ALUNOS
Adolfo Tavares
Alexandre Magno
Alexandre P. Palomo
Ana Carolina Passos Carvalho
Brbara Pimenta Caetano
Berilo Malavolta
Bianca Tella
Claudionor Silva
Domingos Paes
Douglas Carvalho da Silva
Guilherme Augusto Ferreira
Guilherme Lookcan
Iago Felicio Dornelas
Ignacio Andres Torres
Joo Pedro Castro
Jos Ernani Marcondes
Lauro Andr Sampaio
Lucas Machado Coimbra
Luiz Felipe Azevedo
Monica Martins da Costa
Paula Fabrcia da Silva
Pedro Filipe Rodrigues
Pedro Henrique P.
Pedro Salles
Raniere Dantas Janousek
Renan dos Santos Geraldo
Renan Felipe dos Santos Inacio
Ren Soares de Souza
Rodrigo Sanches Coga
Rodson Carvalho
Rolandro Aparecido Correa
Sara Midori Mendes Tomisaki
Thiago Silva
Tulio Max Mendes Moares
Victor Martins Emediato
Vincius Augusto Pereira Guimares

39

REFERNCIAS BIBLIOGRFICAS
Universidade Federal de Santa Maria http://goo.gl/eH1pE

Organizao de Computadores, projeto para o desenho, 8 Ed. http://unifei.bvirtual.com.br/editions/1969-arquitetura-e-organizacao-de-computadoresprojeto-para-o-desempenho-8a-edicao.dp

Accompanying The Essentials of Computer Organization and Architecture 2/e


by Linda Null and Julia Lobur - http://goo.gl/MsVzI

40