Introdução - Prof. Mauro Oliveira

Funcionamento básico de
um computador
• Processador
− Unidade de dados
− Unidade de controlo
• Arquitetura de computador básica
• Linguagem assembly
• Exemplos
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
1
Estrutura de um computador
Processador
Memória
de Instruções
Unidade
de Controlo
Unidade
de Dados
José Delgado © 2012
Memória
de Dados
Periféricos
(entradas/saídas)
Arquitetura de Computadores – Funcionamento básico de um computador
2
Memória: elemento fundamental
Valor a escrever
Processador
Unidade de
Controlo
Célula 0
Célula 1
Célula 2
Célula 3
Célula 4
Célula 5
Célula 6
Célula 7
Célula 8
Célula 9
Célula 10
Célula 11
Célula 12
Célula 13
Célula 14
Célula 15
Endereço
WR
Unidade de
Dados
Memória de
Instruções
Memória de Dados
Periféricos
(entradas/saídas)
Os periféricos são
uma espécie de
células de memória
cujos bits ligam ao
mundo exterior.
Valor lido
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
3
Unidade de dados (versão 1)
• Problema: Um
somador tem
duas entradas,
mas a memória
só tem uma
saída.
• Solução: um
registo para
memorizar um
dos operandos
1 - Endereço do 1.º operando
2 - Endereço do 2.º operando
WR
ESCR_A
Memória de
dados
Registo A
2.º operando
1.º operando
Somador
resultado da soma
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
4
Unidade de dados (versão 2)
• Problema:
Resultado não
pode ir para a
memória
• Solução: Usar o
registo para esse
efeito (não pode
ser latch).
• O registo chama-se
tradicionalmente
“acumulador”.
José Delgado © 2012
endereço do 2.º operando
WR
ESCR_A
Memória de
dados
Registo A
1.º operando
2.º operando
Somador
resultado da soma
Arquitetura de Computadores – Funcionamento básico de um computador
5
Unidade de dados (versão 3)
• Problema: Entrada
do registo não
pode vir de dois
lados (registo e
memória)
• Solução: Usar um
multiplexer para
selecionar a
entrada.
endereço
WR
SEL_A
ESCR_A
Memória de
dados
MUX
Registo A
1.º operando
2.º operando
Somador
resultado da soma
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
6
Unidade de dados (versão 4)
• Problema: Como
guardar resultados
na memória?
• Solução: Ligar
saída do registo à
entrada da
memória (o
resultado vai
sempre para o
registo, depois
copia-se)
endereço
WR
SEL_A
ESCR_A
Memória de
dados
MUX
Registo A
1.º operando
2.º operando
Somador
resultado da soma
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
7
Unidade de dados (versão 5)
• Problema: Como
suportar várias
operações?
• Solução: Usar uma
ALU (Arithmetic and
Logic Unit).
• O sinal SEL_ALU
seleciona a
operação.
endereço
Memória de
dados
WR
SEL_A
ESCR_A
MUX
Registo A
1.º operando 2.º operando
SEL_ALU
ALU
resultado da operação
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
8
Estrutura da ALU
1.º operando
2.º operando
8
8
1
entrada de
transporte
Somador
8
SEL_ALU (0)
SEL_ALU (1)
8
8
Multiplexer
8
resultado
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
9
Instruções com sinais de controlo
endereço de
instruções
Memória de
instruções
Memória
de dados
endereço de dados
WR
SEL_A
MUX
ESCR_A
Registo A
1.º operando
SEL_ALU
2.º operando
ALU
resultado da operação
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
10
Contador de programa (PC)
endereço de
instruções
Memória de
instruções
Memória
de dados
endereço de dados
PC
WR
SEL_A
MUX
ESCR_A
Registo A
1.º operando 2.º operando
SEL_ALU
ALU
resultado da operação
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
11
Vamos fazer um programa!
• Objetivo: somar um número com todos os inteiros
positivos menores que ele.
soma = N + (N-1) + (N-2) + . . . + 2 + 1
1.
2.
3.
4.
5.
6.
7.
8.
soma  0
temp  N
Se (temp < 0) salta para 8
Se (temp = 0) salta para 8
soma  soma + temp
temp  temp – 1
Salta para 4
Salta para 8
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o passo 4)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
12
Variáveis em memória
• soma e temp serão células de memória cujo conteúdo vai
variando ao longo do tempo (o registo A é só para ir efetuando os
cálculos intermédios).
• Cada célula de memória tem um endereço (por exemplo, soma
fica em 40H e temp em 41H).
1.
2.
3.
4.
5.
6.
7.
8.
M[40H]  0
M[41H]  N
Se (M[41H] < 0) salta para 8
Se (M[41H] = 0) salta para 8
M[40H]  M[40H] + M[41H]
M[41H]  M[41H] – 1
Salta para 4
Salta para 8
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o passo 4)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
13
Constantes simbólicas
• Endereços só números é muito confuso!
• Constante simbólica = identificador com um valor
• Define-se uma vez e depois pode usar-se como se fosse o número
com que ela foi definida.
soma
temp
1.
2.
3.
4.
5.
6.
7.
8.
EQU
EQU
40H
41H
(definição do endereço da variável soma)
(definição do endereço da variável temp)
M[soma]  0
M[temp]  N
Se (M[temp] < 0) salta para 8
Se (M[temp] = 0) salta para 8
M[soma]  M[soma] + M[temp]
M[temp]  M[temp] – 1
Salta para 4
Salta para 8
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o passo 4)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
14
Endereços de dados e de
instruções
•
•
•
•
As variáveis ficam na memórias de dados
As instruções ficam na memória de instruções
Cada passo do algoritmo é uma instrução
O número do passo é o endereço na memória de instruções
soma
temp
1.
2.
3.
4.
5.
6.
7.
8.
EQU
EQU
40H
41H
(definição do endereço da variável soma)
(definição do endereço da variável temp)
M[soma]  0
M[temp]  N
Se (M[temp] < 0) salta para 8
Se (M[temp] = 0) salta para 8
M[soma]  M[soma] + M[temp]
M[temp]  M[temp] – 1
Salta para 4
Salta para 8
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o passo 4)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
15
PC (Contador de Programa)
• O PC vai evoluindo instrução a instrução (mas os endereços das
memórias começam em 0 e não em 1).
• Após cada instrução, o PC contém o endereço da instrução
seguinte.
• “Saltar” equivale a escrever um novo valor no PC.
soma
temp
0
1
2
3
4
5
6
7
EQU
EQU
40H
41H
(definição do endereço da variável soma)
(definição do endereço da variável temp)
M[soma]  0
M[temp]  N
Se (M[temp] < 0) PC  7
Se (M[temp] = 0) PC  7
M[soma]  M[soma] + M[temp]
M[temp]  M[temp] – 1
PC  3
PC  7
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o endereço 3)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
16
Vamos somar!
Número de instruções executadas
10
11
12
13
14
15
16
17
18
19
20
0
1
2
3
4
5
6
7
8
9
Valores após a execução da instrução (PC endereça a seguinte):
soma
temp
0
1
2
3
4
5
6
7
soma
0
1
2
4
5
6
3
7
PC
EQU
EQU
40H
41H
0
3
5
6
temp
3
2
1
0
(definição do endereço da variável soma)
(definição do endereço da variável temp)
M[soma]  0
M[temp]  N
Se (M[temp] < 0) PC  7
Se (M[temp] = 0) PC  7
M[soma]  M[soma] + M[temp]
M[temp]  M[temp] – 1
PC  3
PC  7
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o endereço 3)
(fim do programa)
Já chega!!!!
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
17
Constantes
• Cada instrução pode ter de 1 a 3 constantes.
• Tamanho das instruções:
– variável (complica o controlo), ou
– fixo com 3 constantes (desperdício de memória).
Constantes
soma
0
temp
N
temp
0
7
temp
0
7
soma
soma
temp
temp
temp
1
3
7
José Delgado © 2012
0
1
2
3
4
5
6
7
M[soma]  0
M[temp]  N
Se (M[temp] < 0) PC  7
Se (M[temp] = 0) PC  7
M[soma]  M[soma] + M[temp]
M[temp]  M[temp] – 1
PC  3
PC  7
Arquitetura de Computadores – Funcionamento básico de um computador
18
Solução para as constantes
•
•
•
Decompôr instruções com várias constantes em instruções mais
simples, cada uma só com uma constante.
Já não há endereços e valores numéricos na mesma instrução.
Usa-se um registo auxiliar (A) para guardar valores entre instruções.
0
1
2
3
A0
M[soma]  A
AN
M[temp]  A
Se (M[temp] < 0) PC  7
4
(A < 0) : PC  12
3
Se (M[temp] = 0) PC  7
4
M[soma]  M[soma] + M[temp]
5
M[temp]  M[temp] – 1
6
7
PC  3
PC  7
5
6
7
8
9
10
11
12
(A = 0) : PC  12
A  A + M[soma]
M[soma]  A
A  M[temp]
AA–1
M[temp]  A
PC  5
PC  12
0
M[soma]  0
1
M[temp]  N
2
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
19
Que operações são necessárias?
• Para correr o programa anterior, o hardware tem de suportar
as seguintes operações:
Operação
Exemplo
Escrever uma constante no registo A
A0
Armazenar o registo A na memória
M[soma]  A
Ler uma célula de memória e escrever no
A  M[temp]
registo A
Operação com o registo A e uma célula
de memória como operandos
A  A + M[soma]
Operação com o registo A e uma
constante como operandos
AA–1
Salto incondicional
PC  7
Salto condicional
(A = 0) : PC  12
• Esta notação designa-se RTL (Register Transfer Language)
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
20
Linguagem assembly
Instrução
Categoria
Transferência de
dados
Operações
aritméticas
Operações
lógicas
Saltos
Diversos
assembly
Significado
Opcode
Descrição em RTL
LD
valor
Load (imediato)
00H
A  valor
LD
[endereço]
Load (memória)
01H
A  M[endereço]
ST
[endereço]
Store (memória)
02H
M[endereço]  A
ADD
valor
Add (imediato)
03H
A  A + valor
ADD
[endereço]
Add (memória)
04H
A  A + M[endereço]
SUB
valor
Subtract (imediato)
05H
A  A – valor
SUB
[endereço]
Subtract (memória)
06H
A  A – M[endereço]
AND
valor
AND (imediato)
07H
A  A  valor
AND
[endereço]
AND (memória)
08H
A  A  M[endereço]
OR
valor
OR (imediato)
09H
A  A  valor
OR
[endereço]
OR (memória)
0AH
A  A  M[endereço]
JMP
endereço
Jump
0BH
PC  endereço
JZ
endereço
Jump if zero
0CH
(A=0) : PC  endereço
JN
endereço
Jump if negative
0DH
(A<0) : PC  endereço
No operation
0EH
NOP
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
21
Programação em assembly
Programa em RTL
0
1
2
3
4
5
6
7
8
9
10
11
12
A0
M[soma]  A
AN
M[temp]  A
(A < 0) : PC  12
(A = 0) : PC  12
A  A + M[soma]
M[soma]  A
A  M[temp]
AA–1
M[temp]  A
PC  5
PC  12
José Delgado © 2012
Programa em assembly
00H início: LD
01H
ST
02H
LD
03H
ST
04H
JN
05H teste: JZ
06H
ADD
07H
ST
08H
LD
09H
SUB
0AH
ST
0BH
JMP
0CH fim:
JMP
0
[soma]
N
[temp]
fim
fim
[soma]
[soma]
[temp]
1
[temp]
teste
fim
Arquitetura de Computadores – Funcionamento básico de um computador
22
Vamos “assemblar”!
Opcode
00H
01H
02H
03H
04H
05H
06H
07H
08H
09H
0AH
0BH
0CH
0DH
0EH
Assembly
LD
LD
ST
ADD
ADD
SUB
SUB
AND
AND
OR
OR
JMP
JZ
JN
NOP
End.
Assembly
Máquina
0
00H início: LD
valor
01H
ST
[soma]
[endereço]
[endereço]
02H
LD
N
valor
03H
ST
[temp]
[endereço]
04H
JN
fim
valor
05H teste: JZ
fim
[endereço]
06H
ADD [soma]
valor
07H
ST
[soma]
[endereço]
08H
LD
[temp]
são convertidas
valor • As mnemónicas
09H
SUB 1
[endereçem
o] opcodes
0AH
ST
[temp]
endereço
0BH simbólicas
JMP são
teste
• çoAs constantes
endere
0CH
JMP fim
emfim:
números
endereçoconvertidas
00 00H
02 40H
00 08H
02 41H
0D 0CH
0C 0CH
04 40H
02 40H
01 41H
05 01H
02 41H
0B 05H
0B 0CH
• Assumindo: soma = 40H; temp = 41H; N = 8
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
23
Além da memória: periféricos
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
WR
Endereço
de instruções Instrução
8
Memória
de
dados
Endereço
WR
1
Dados
(entrada)
12
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
Periférico 0
de
entrada
Verde
1
0
RD
Arquitetura de Computadores – Funcionamento básico de um computador
24
Problema na escrita
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
WR
Endereço
de instruções Instrução
8
Memória
de
dados
Endereço
WR
1
Dados
(entrada)
12
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
Periférico 0
de
entrada
Verde
1
0
RD
Arquitetura de Computadores – Funcionamento básico de um computador
25
Problema na leitura
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
WR
Endereço
de instruções Instrução
8
Memória
de
dados
Endereço
WR
1
Dados
(entrada)
12
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
Periférico 0
de
entrada
Verde
1
0
RD
Arquitetura de Computadores – Funcionamento básico de um computador
26
Registos com saída tri-state
• Com saída em
tri-state, podem
ligar-se várias
saídas entre si
(mas só uma
pode ter o buffer
tri-state ligado!)
José Delgado © 2012
D
C
N
Registo
N bits
Q
N
Buffer tri-state
• Saídas normais
ligadas entre si
podem dar
conflito.
N
saída
OE - Output Enable
Output Enable
Saída
Activo
Q
Inactivo
Desligada
Arquitetura de Computadores – Funcionamento básico de um computador
27
Solução: acesso selectivo
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
WR
Endereço
de instruções Instrução
8
12
1
1
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Verde
1
0
Arquitetura de Computadores – Funcionamento básico de um computador
28
Acesso à memória/periféricos
WR
Sinais
Inativo (1) - leitura
Inativo (1)
Memória
Ativo (0) - escrita
Sem efeito no dispositivo
Lê dados
Escreve dados
Lê dados
Sem efeito
Sem efeito
Escreve dados
CS
Ativo (0) Periférico de
entrada
Periférico de
saída
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
29
Mapa de endereços
Dispositivo
Gama de endereços em
escrita (WR ativo)
Gama de endereços em
leitura (WR inativo)
Memória de dados
0 – 127
(00H – 7FH)
0 – 127
(00H – 7FH)
Periférico de saída
128 – 255
(80H – FFH)
Nenhum (o sinal WR do
periférico está inativo)
Periférico de entrada
Nenhum (o sinal RD do
periférico está inativo)
128 – 255
(80H – FFH)
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
30
Escrita na memória de dados
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
WR
Endereço
de instruções Instrução
8
12
1
1
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Verde
1
0
Arquitetura de Computadores – Funcionamento básico de um computador
31
Escrita no periférico de saída
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
WR
Endereço
de instruções Instrução
8
12
1
1
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Verde
1
0
Arquitetura de Computadores – Funcionamento básico de um computador
32
Leitura da memória de dados
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
WR
Endereço
de instruções Instrução
8
12
1
1
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Verde
1
0
Arquitetura de Computadores – Funcionamento básico de um computador
33
Leitura do periférico de entrada
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
WR
Endereço
de instruções Instrução
8
12
1
1
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
Vermelho
0
Periférico
de 1
saída
Amarelo
2
Endereço
Instrução
de instruções
Memória
de instruções
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Verde
1
0
Arquitetura de Computadores – Funcionamento básico de um computador
34
Programa: semáforo simples
; constantes de dados
vermelho
EQU
01H
amarelo
EQU
02H
verde
EQU
04H
; valor do vermelho (lâmpada liga ao bit 0)
; valor do amarelo (lâmpada liga ao bit 1)
; valor do verde (lâmpada liga ao bit 2)
; constantes de endereços
semáforo
EQU
80H
; endereço 128 (periférico de saída)
; programa
início:
LD
ST
semVerde: NOP
NOP
NOP
LD
ST
semAmarelo: LD
ST
semVerm:
NOP
NOP
NOP
NOP
JMP
verde
[semáforo]
amarelo
[semáforo]
vermelho
[semáforo]
início
;
;
;
;
;
;
;
;
;
;
;
;
;
;
Carrega o registo A com o valor para semáforo verde
Atualiza o periférico de saída
8
Dados
Dados
faz um compasso de espera
(saída)
(entrada)
8
Dados
Dados
faz um compasso de espera
Memória
(entrada)
(saída)
de
faz um compasso
de Endereço
espera
8
dados
Processador
Endereço
de dados
1
bit de para
maior peso
CS
Carrega o registo A com
o valor
semáforo
amarelo
WR
WR
Atualiza o periférico de saída
Endereço
Carrega o registo
A com
Instruçãoo valor para semáforo vermelho
de instruções
Dados
1
(entrada)
Atualiza o periférico de saída
Periférico
12
8
CS
de
faz um compasso de espera
saída
WR
faz um compasso de espera
faz um compasso
espera
EndereçodeInstrução
de instruções
Dados
faz um compasso de espera
(saída) Periférico
de
vai fazer mais uma
ronda
CS
Memória
de instruções
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
0
1
2
0
entrada
RD
35
1
0
Programa (cont.)
Processador
Dados
(saída)
8
Dados
(entrada)
Dados
(entrada)
8
Dados
(saída)
Endereço
de dados
8
bit de maior peso
1
WR
; constantes de dados
vermelho
EQU
01H
amarelo
EQU
02H
verde
EQU
04H
; constantes de endereços
semáforo
EQU
80H
Endereço
de instruções Instrução
1
; valor do vermelho (lâmpada liga ao bit 0)
12
8
; valor do amarelo
(lâmpada liga ao bit 1)
; valor do verde (lâmpada liga ao bit 2)
Endereço
Instrução
de instruções
; endereço 128 (periférico
de saída)
Memória
de instruções
; programa
início:
LD
ST
semVerde: NOP
NOP
NOP
LD
ST
semAmarelo: LD
ST
semVerm:
NOP
NOP
NOP
NOP
JMP
verde
[semáforo]
amarelo
[semáforo]
vermelho
[semáforo]
início
José Delgado © 2012
;
;
;
;
;
;
;
;
;
;
;
;
;
;
Memória
de
dados
Endereço
CS
WR
0
Dados
(entrada)
CS
WR
Periférico
de 1
saída
2
Dados
(saída)
CS
RD
Periférico 0
de
entrada
Carrega o registo A com o valor para semáforo verde
Atualiza o periférico de saída
faz um compasso de espera
faz um compasso de espera
faz um compasso de espera
Carrega o registo A com o valor para semáforo amarelo
Atualiza o periférico de saída
Carrega o registo A com o valor para semáforo vermelho
Atualiza o periférico de saída
faz um compasso de espera
faz um compasso de espera
faz um compasso de espera
faz um compasso de espera
vai fazer mais uma ronda
Arquitetura de Computadores – Funcionamento básico de um computador
36
1
0
Vamos correr o programa!
Processador
Dados
(saída)
8
Dados
(entrada)
8
Endereço
de dados
8
bit de maior peso
Dados
(entrada)
Dados
(saída)
1
WR
Endereço
de instruções Instrução
8
início:
1
12
Memória
de
dados
Endereço
CS
WR
Dados
(entrada)
CS
WR
0
Periférico
de 1
saída
2
Endereço
Instrução
de instruções
Memória
de instruções
Passo a passo
José Delgado © 2012
Dados
(saída)
CS
RD
Periférico 0
de
entrada
1
0
LD
ST
semVerde:
NOP
NOP
NOP
LD
ST
semAmarelo: LD
ST
semVerm:
NOP
NOP
NOP
NOP
JMP
Contínuo
verde
[semáforo]
amarelo
[semáforo]
vermelho
[semáforo]
início
Seguinte
Arquitetura de Computadores – Funcionamento básico de um computador
37
Outro exemplo:
contar bits a 1 em 76H
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
máscara  01H
Se (máscara  valor = 0) salta para 5
contador  contador + 1
Se (máscara = 80H) salta para 8
máscara  máscara + máscara
Salta para 3
Salta para 8
posição
em teste
0
1
2
3
4
5
6
7
(inicializa contador de bits a zero)
(inicializa máscara a 0000 0001)
(se o bit está a zero, passa ao próximo)
(bit está a 1, incrementa contador)
(se já testou a última máscara, termina)
(duplica máscara para deslocar bit para a esquerda)
(vai testar o novo bit)
(fim do algoritmo)
Máscara
Valor (76H)
Valor AND máscara
Bit a 1
0000 0001
0000 0010
0000 0100
0000 1000
0001 0000
0010 0000
0100 0000
1000 0000
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0000 0000
0000 0010
0000 0100
0000 0000
0001 0000
0010 0000
0100 0000
0000 0000
Não
Sim
Sim
Não
Sim
Sim
Sim
Não
José Delgado © 2012
Contador
de bits a 1
0
1
2
2
3
4
5
5
Arquitetura de Computadores – Funcionamento básico de um computador
40
Programa para contar bits a 1
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
contador
EQU
00H
máscara
EQU
01H
início:
LD
ST
LD
ST
AND
JZ
LD
ADD
ST
LD
SUB
JZ
LD
ADD
ST
JMP
JMP
0
[contador]
máscaraInicial
[máscara]
valor
próximo
[contador]
1
[contador]
[máscara]
máscaraFinal
fim
[máscara]
[máscara]
[máscara]
teste
fim
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
teste:
próximo:
fim:
José Delgado © 2012
Endereço da célula de memória que guarda
o valor corrente do contador de bits a 1
Endereço da célula de memória que guarda
o valor corrente da máscara
Inicializa o registo A a zero
Inicializa o contador de bits com zero
Carrega valor da máscara inicial
Atualiza na memória
Isola o bit que se quer ver se é 1
Se o bit for zero, passa à máscara seguinte
O bit é 1, vai buscar o valor atual do contador
Incrementa-o
e atualiza de novo na memória
Vai buscar de novo a máscara atual
Compara com a máscara final, fazendo a subtração
Se der zero, eram iguais e portanto já terminou
Tem de carregar a máscara de novo
Soma com ela própria para a multiplicar por 2
Atualiza o valor da máscara na memória
Vai fazer mais um teste com a nova máscara
Fim do programa
Arquitetura de Computadores – Funcionamento básico de um computador
41
Definições
valor
EQU 76H
máscaraInicial EQU 01H
máscaraFinal EQU 80H
contador
máscara
início:
teste:
próximo:
fim:
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
EQU 00H
; Endereço da célula de memória que guarda
; o valor corrente do contador de bits a 1
EQU 01H
; Endereço da célula de memória que guarda
; o valor corrente da máscara
LD
0
; Inicializa o registo A a zero
ST
[contador]
; Inicializa o contador de bits com zero
LD
máscaraInicial ; Carrega valor da máscara inicial
ST
[máscara]
; Atualiza na memória
AND valor
; Isola o bit que se quer ver se é 1
JZ
próximo
; Se o bit for zero, passa à máscara seguinte
LD
[contador]
; O bit é 1, vai buscar o valor atual do contador
ADD 1
; Incrementa-o
ST
[contador]
; e atualiza de novo na memória
LD
[máscara]
; Vai buscar de novo a máscara atual
SUB máscaraFinal ; Compara com a máscara final, fazendo a subtração
JZ
fim
; Se der zero, eram iguais e portanto já terminou
LD
[máscara]
; Tem de carregar a máscara de novo
ADD [máscara]
; Soma com ela própria para a multiplicar por 2
ST
[máscara]
; Atualiza o valor da máscara na memória
JMP teste
; Vai fazer mais um teste com a nova máscara
JMP fim
; Fim do programa
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
42
Inicializa “contador”
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
contador
EQU
00H
máscara
EQU
01H
; Endereço da célula de memória que guarda
; o valor corrente do contador de bits a 1
; Endereço da célula de memória que guarda
; o valor corrente da máscara
; Inicializa o registo A a zero
; Inicializa o contador de bits com zero
; Carrega valor da máscara inicial
; Atualiza na memória
; Isola o bit que se quer ver se é 1
; Se o bit for zero, passa à máscara seguinte
; O bit é 1, vai buscar o valor atual do contador
; Incrementa-o
; e atualiza contador
de novo nade
memória
(inicializa
bits a zero)
;
vai
buscar
de
novo
a
máscara
(inicializa máscara a 0000 0001) atual
; compara com a máscara final, fazendo a subtração
(se
bit zero,
está aeram
zero,iguais
passaeao
próximo)
; seoder
portanto
já terminou
(bit
está
a
1,
incrementa
contador)
; tem de carregar a máscara de novo
; soma
com ela
própria
para a multiplicar
(se
já testou
a última
máscara,
termina) por 2
; atualizamáscara
o valor para
da máscara
(duplica
deslocarnabitmemória
para a esquerda)
; vai fazer mais um teste com a nova máscara
(vai testar o novo bit)
; fim do programa
(fim do algoritmo)
início:
LD
0
ST
[contador]
LD
máscaraInicial
ST
[máscara]
teste:
AND valor
JZ
próximo
LD
[contador]
ADD 1
ST
[contador]
1. contador  0
próximo:
[máscara]
2. máscara
 01H LD
SUB máscaraFinal
3. Se (máscara  valor
JZ = 0)
fimsalta para 5
4. contador  contador
1
LD +[máscara]
ADDsalta
[máscara]
5. Se (máscara = 80H)
para 8
ST + [máscara]
6. máscara  máscara
máscara
JMP teste
7. Salta para 3
fim:
JMP fim
8. Salta para 8
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
43
Inicializa “máscara”
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
contador
00H
EQU
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
; Endereço da célula de memória que guarda
; o valor corrente do contador de bits a 1
máscara
EQU 01H
; Endereço da célula de memória que guarda
; o valor corrente da máscara
início:
LD
0
; Inicializa o registo A a zero
ST
[contador]
; Inicializa o contador de bits com zero
LD
máscaraInicial ; Carrega valor da máscara inicial
ST
[máscara]
; Atualiza na memória
teste:
AND valor
; Isola o bit que se quer ver se é 1
JZ
próximo
; Se o bit for zero, passa à máscara seguinte
LD
[contador]
; O bit é 1, vai buscar o valor atual do contador
ADD 1
; Incrementa-o
ST
[contador]
; e atualiza
de novodenabits
memória
1. contador  0
(inicializa
contador
a zero)
próximo:
LD
[máscara]
;
vai
buscar
de
novo
a
máscara
atual
2. máscara  01H
(inicializa máscara a 0000 0001)
SUB máscaraFinal
; compara com a máscara final, fazendo a subtração
3. Se (máscara  valor
bit zero,
está aeram
zero,iguais
passaeao
próximo)
JZ = 0)
fimsalta para 5 (se
; seoder
portanto
já terminou
4. contador  contador
+
1
(bit
está
a
1,
incrementa
contador)
LD
[máscara]
; tem de carregar a máscara de novo
ADDsalta
[máscara]
; soma
com ela
própria
para a multiplicar
5. Se (máscara = 80H)
para 8
(se
já testou
a última
máscara,
termina) por 2
ST + [máscara]
; atualizamáscara
o valor para
da máscara
6. máscara  máscara
máscara
(duplica
deslocarnabitmemória
para a esquerda)
JMP teste
; vai fazer mais um teste com a nova máscara
7. Salta para 3
(vai testar o novo bit)
fim:
JMP fim
; fim do programa
8. Salta para 8
(fim do algoritmo)
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
44
AND de “máscara” e “valor”
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
contador
00H
EQU
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
; Endereço da célula de memória que guarda
; o valor corrente do contador de bits a 1
máscara
EQU 01H
; Endereço da célula de memória que guarda
; o valor corrente da máscara
início:
LD
0
; Inicializa o registo A a zero
ST
[contador]
; Inicializa o contador de bits com zero
LD
máscaraInicial ; Carrega valor da máscara inicial
ST
[máscara]
; Atualiza na memória
teste:
AND valor
; Isola o bit que se quer ver se é 1
JZ
próximo
; Se o bit for zero, passa à máscara seguinte
LD
[contador]
; O bit é 1, vai buscar o valor atual do contador
ADD 1
; Incrementa-o
ST
[contador]
; e atualiza
de novodenabits
memória
1. contador  0
(inicializa
contador
a zero)
próximo:
LD
[máscara]
;
vai
buscar
de
novo
a
máscara
2. máscara  01H
(inicializa máscara a 0000 0001) atual
SUB máscaraFinal
; compara com a máscara final, fazendo a subtração
3. Se (máscara  valor
0) salta para 5 ;(se
bit
estáeram
a zero,
passa
ao próximo)
JZ = fim
se o
der
zero,
iguais
e portanto
já terminou
4. contador  contador
+
1
(bit
está
a
1,
incrementa
contador)
LD
[máscara]
; tem de carregar a máscara de novo
ADDsalta
[máscara]
; soma
com ela
própria
para a multiplicar
5. Se (máscara = 80H)
para 8
(se
já testou
a última
máscara,
termina) por 2
ST + [máscara]
; atualizamáscara
o valor para
da máscara
6. máscara  máscara
máscara
(duplica
deslocarnabitmemória
para a esquerda)
JMP teste
; vai fazer mais um teste com a nova máscara
7. Salta para 3
(vai testar o novo bit)
fim:
JMP fim
; fim do programa
8. Salta para 8
(fim do algoritmo)
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
45
Incrementa “contador”
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
contador
00H
EQU
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
; Endereço da célula de memória que guarda
; o valor corrente do contador de bits a 1
máscara
EQU 01H
; Endereço da célula de memória que guarda
; o valor corrente da máscara
início:
LD
0
; Inicializa o registo A a zero
ST
[contador]
; Inicializa o contador de bits com zero
LD
máscaraInicial ; Carrega valor da máscara inicial
ST
[máscara]
; Atualiza na memória
teste:
AND valor
; Isola o bit que se quer ver se é 1
JZ
próximo
; Se o bit for zero, passa à máscara seguinte
LD
[contador]
; O bit é 1, vai buscar o valor atual do contador
ADD 1
; Incrementa-o
ST
[contador]
; e atualiza de novo na memória
próximo:
LD
[máscara]
; vai buscar de novo a máscara atual
SUB máscaraFinal
; compara com a máscara final, fazendo a subtração
1. contador  0 JZ
(inicializa
contador
de bits
a zero) já terminou
fim
; se
der zero,
eram iguais
e portanto
2. máscara  01HLD
(inicializa
máscara
a 0000 0001)
[máscara]
; tem
de carregar
a máscara
de novo
[máscara]
ela aprópria
para aaomultiplicar
3. Se (máscara  ADD
valor =
0) salta para 5 ; soma
(se o com
bit está
zero, passa
próximo) por 2
ST
[máscara]
; atualiza
o valor
da máscara na
memória
4. contador  contador
+1
(bit está
a 1, incrementa
contador)
JMP teste
; vai fazer mais um teste com a nova máscara
5. Se
(máscara = JMP
80H) salta
(se do
já testou
a última máscara, termina)
fim:
fim para 8
; fim
programa
6. máscara  máscara + máscara
(duplica máscara para deslocar bit para a esquerda)
7. Salta para 3
(vai testar o novo bit)
8. Salta para
(fim
do algoritmo)
José8Delgado © 2012
Arquitetura de
Computadores
– Funcionamento básico de um computador
46
Testa “máscara”
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
valor  01H EQU 76H
máscara
máscaraInicial EQU 01H
Se (máscara  valor = 0) salta para 5
máscaraFinal EQU 80H
contador  contador + 1
Secontador
(máscara = 80H)
EQU salta
00H para 8
máscara  máscara + máscara
máscara
EQU 01H
Salta
para 3
Salta
para 8
início:
LD
0
ST
[contador]
LD
máscaraInicial
ST
[máscara]
teste:
AND valor
JZ
próximo
LD
[contador]
ADD 1
ST
[contador]
próximo:
LD
[máscara]
SUB máscaraFinal
JZ
fim
LD
[máscara]
ADD [máscara]
ST
[máscara]
JMP teste
fim:
JMP fim
José Delgado © 2012
(inicializa contador de bits a zero)
; valor cujo
número
de bits0001)
a 1 é para ser contado
(inicializa
máscara
a 0000
; 0000 0001 em binário (máscara inicial)
(se o bit está a zero, passa ao próximo)
; 1000 0000 em binário (máscara final)
(bit está a 1, incrementa contador)
(se
já testou
última
máscara,
termina)
; endereço
da a
célula
de memória
que
guarda
;
o
valor
corrente
do
contador
de
bits
(duplica máscara para deslocar bit paraa a1 esquerda)
; endereço
célula
(vai
testar oda
novo
bit)de memória que guarda
; o valor corrente da máscara
(fim
do algoritmo)
; Inicializa
o registo A a zero
; Inicializa o contador de bits com zero
; Carrega valor da máscara inicial
; Atualiza na memória
; Isola o bit que se quer ver se é 1
; Se o bit for zero, passa à máscara seguinte
; O bit é 1, vai buscar o valor atual do contador
; Incrementa-o
; e atualiza de novo na memória
; Vai buscar de novo a máscara atual
; Compara com a máscara final, fazendo a subtração
; Se der zero, eram iguais e portanto já terminou
; Tem de carregar a máscara de novo
; Soma com ela própria para a multiplicar por 2
; Atualiza o valor da máscara na memória
; Vai fazer mais um teste com a nova máscara
; Fim do programa
Arquitetura de Computadores – Funcionamento básico de um computador
47
Duplica “máscara”
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
valor  01H EQU 76H
máscara
máscaraInicial EQU 01H
Se (máscara  valor = 0) salta para 5
máscaraFinal EQU 80H
contador  contador + 1
Se contador
(máscara = 80H)
para 8
EQUsalta
00H
máscara  máscara + máscara
máscara
EQU 01H
Salta
para 3
Salta
para 8
início:
LD
0
ST
[contador]
LD
máscaraInicial
ST
[máscara]
teste:
AND valor
JZ
próximo
LD
[contador]
ADD 1
ST
[contador]
próximo:
LD
[máscara]
SUB máscaraFinal
JZ
fim
LD
[máscara]
ADD [máscara]
ST
[máscara]
JMP teste
fim:
JMP fim
José Delgado © 2012
(inicializa contador de bits a zero)
; valor cujo
número
de bits0001)
a 1 é para ser contado
(inicializa
máscara
a 0000
; 0000 0001 em binário (máscara inicial)
(se o bit está a zero, passa ao próximo)
; 1000 0000 em binário (máscara final)
(bit está a 1, incrementa contador)
(se
já testouda
a célula
última de
máscara,
termina)
; endereço
memória
que guarda
;
o
valor
corrente
do
contador
de
bits
1
(duplica máscara para deslocar
bita para
a esquerda)
;
endereço
da
célula
de
memória
que
guarda
(vai testar o novo bit)
; o valor corrente da máscara
(fim
do algoritmo)
; Inicializa
o registo A a zero
; Inicializa o contador de bits com zero
; Carrega valor da máscara inicial
; Atualiza na memória
; Isola o bit que se quer ver se é 1
; Se o bit for zero, passa à máscara seguinte
; O bit é 1, vai buscar o valor atual do contador
; Incrementa-o
; e atualiza de novo na memória
; Vai buscar de novo a máscara atual
; Compara com a máscara final, fazendo a subtração
; Se der zero, eram iguais e portanto já terminou
; Tem de carregar a máscara de novo
; Soma com ela própria para a multiplicar por 2
; Atualiza o valor da máscara na memória
; Vai fazer mais um teste com a nova máscara
; Fim do programa
Arquitetura de Computadores – Funcionamento básico de um computador
48
Salta para “teste”
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
valor  01H EQU 76H
máscara
máscaraInicial EQU 01H
Se (máscara  valor = 0) salta para 5
máscaraFinal EQU 80H
contador  contador + 1
Se contador
(máscara = 80H)
para 8
EQUsalta
00H
máscara  máscara + máscara
máscara
EQU 01H
Salta
para 3
Salta
para 8
início:
LD
0
ST
[contador]
LD
máscaraInicial
ST
[máscara]
teste:
AND valor
JZ
próximo
LD
[contador]
ADD 1
ST
[contador]
próximo:
LD
[máscara]
SUB máscaraFinal
JZ
fim
LD
[máscara]
ADD [máscara]
ST
[máscara]
JMP teste
fim:
JMP fim
José Delgado © 2012
(inicializa contador de bits a zero)
; valor cujo
número
de bits0001)
a 1 é para ser contado
(inicializa
máscara
a 0000
; 0000 0001 em binário (máscara inicial)
(se o bit está a zero, passa ao próximo)
; 1000 0000 em binário (máscara final)
(bit está a 1, incrementa contador)
(se
já testouda
a célula
última de
máscara,
termina)
; endereço
memória
que guarda
;
o
valor
corrente
do
contador
de
(duplica máscara para deslocar bitbits
paraa a1 esquerda)
; endereço
célulabit)
de memória que guarda
(vai
testar da
o novo
; o valor corrente da máscara
(fim
do algoritmo)
; Inicializa
o registo A a zero
; Inicializa o contador de bits com zero
; Carrega valor da máscara inicial
; Atualiza na memória
; Isola o bit que se quer ver se é 1
; Se o bit for zero, passa à máscara seguinte
; O bit é 1, vai buscar o valor atual do contador
; Incrementa-o
; e atualiza de novo na memória
; Vai buscar de novo a máscara atual
; Compara com a máscara final, fazendo a subtração
; Se der zero, eram iguais e portanto já terminou
; Tem de carregar a máscara de novo
; Soma com ela própria para a multiplicar por 2
; Atualiza o valor da máscara na memória
; Vai fazer mais um teste com a nova máscara
; Fim do programa
Arquitetura de Computadores – Funcionamento básico de um computador
49
Salta para “fim”
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
valor  01H EQU 76H
máscara
máscaraInicial EQU 01H
Se (máscara  valor = 0) salta para 5
máscaraFinal EQU 80H
contador  contador + 1
Se contador
(máscara = 80H)
para 8
EQUsalta
00H
máscara  máscara + máscara
máscara
EQU 01H
Salta
para 3
Salta
para 8
início:
LD
0
ST
[contador]
LD
máscaraInicial
ST
[máscara]
teste:
AND valor
JZ
próximo
LD
[contador]
ADD 1
ST
[contador]
próximo:
LD
[máscara]
SUB máscaraFinal
JZ
fim
LD
[máscara]
ADD [máscara]
ST
[máscara]
JMP teste
fim:
JMP fim
José Delgado © 2012
(inicializa contador de bits a zero)
; valor cujo
número
de bits0001)
a 1 é para ser contado
(inicializa
máscara
a 0000
; 0000 0001 em binário (máscara inicial)
(se o bit está a zero, passa ao próximo)
; 1000 0000 em binário (máscara final)
(bit está a 1, incrementa contador)
(se
já testouda
a célula
última de
máscara,
termina)
; endereço
memória
que guarda
;
o
valor
corrente
do
contador
de
(duplica máscara para deslocar bitbits
paraa a1 esquerda)
; endereço
célula
(vai
testar oda
novo
bit)de memória que guarda
; o valor corrente da máscara
(fim
do algoritmo)
; Inicializa
o registo A a zero
; Inicializa o contador de bits com zero
; Carrega valor da máscara inicial
; Atualiza na memória
; Isola o bit que se quer ver se é 1
; Se o bit for zero, passa à máscara seguinte
; O bit é 1, vai buscar o valor atual do contador
; Incrementa-o
; e atualiza de novo na memória
; Vai buscar de novo a máscara atual
; Compara com a máscara final, fazendo a subtração
; Se der zero, eram iguais e portanto já terminou
; Tem de carregar a máscara de novo
; Soma com ela própria para a multiplicar por 2
; Atualiza o valor da máscara na memória
; Vai fazer mais um teste com a nova máscara
; Fim do programa
Arquitetura de Computadores – Funcionamento básico de um computador
50
Um só registo  muitas instruções
valor
EQU
máscaraInicial EQU
máscaraFinal EQU
76H
01H
80H
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
contador
EQU
00H
máscara
EQU
01H
início:
LD
ST
LD
ST
AND
JZ
LD
ADD
ST
LD
SUB
JZ
LD
ADD
ST
JMP
JMP
0
[contador]
máscaraInicial
[máscara]
valor
próximo
[contador]
1
[contador]
[máscara]
máscaraFinal
fim
[máscara]
[máscara]
[máscara]
teste
fim
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
teste:
próximo:
fim:
José Delgado © 2012
Endereço da célula de memória que guarda
o valor corrente do contador de bits a 1
Endereço da célula de memória que guarda
o valor corrente da máscara
Inicializa o registo A a zero
Inicializa o contador de bits com zero
Carrega valor da máscara inicial
Atualiza na memória
Isola o bit que se quer ver se é 1
Se o bit for zero, passa à máscara seguinte
O bit é 1, vai buscar o valor atual do contador
Incrementa-o
e atualiza de novo na memória
Vai buscar de novo a máscara atual
Compara com a máscara final, fazendo a subtração
Se der zero, eram iguais e portanto já terminou
Tem de carregar a máscara de novo
Soma com ela própria para a multiplicar por 2
Atualiza o valor da máscara na memória
Vai fazer mais um teste com a nova máscara
Fim do programa
Isto é só para
incrementar a
Tudo na
variável na
memória! Mas
memória!
tudo passa
Isto
é só
para
pelo
registo!
inicializar a
variável na
memória!
Arquitetura de Computadores – Funcionamento básico de um computador
51
Se houvesse 3 registos…
valor
máscaraInicial
máscaraFinal
EQU
EQU
EQU
76H
01H
80H
; Valor cujo número de bits a 1 é para ser contado
; 0000 0001 em binário (máscara inicial)
; 1000 0000 em binário (máscara final)
LD
MOV
e instrução
ST
de
Cada
tem
Mais
simples!
; Utilização dos registos:
passam
registo
para
doispara
operandos
; A – valores intermédios
; B – valor atual do contador de bits a 1
registo
MOV
Incrementar
a à
Um
só acesso
(primeiro
designa
; C – valor atual da máscara
memória!
e não
variável
só
contador
EQU
00H
; Endereço da célula
deresultado
memóriaéque
guardará
; o número de bits a 1 no fim da contagem
pode
constante)
assim!
início:
MOV B, 0
; Inicializa o contador
de bits ser
com zero
acaba:
MOV
MOV
AND
JZ
ADD
CMP
JZ
ADD
JMP
MOV
C, máscaraInicial
A, C
A, valor
próximo
B, 1
C, máscaraFinal
acaba
C, C
teste
[contador], B
fim:
JMP
fim
teste:
próximo:
José Delgado © 2012
;
;
;
;
;
;
;
;
;
;
;
;
Inicializa registo C com valor da máscara inicial
Coloca também a máscara inicial no registo A
Isola o bit que se quer ver se é 1
Se o bit for zero, passa à máscara seguinte
O bit é 1, incrementa o valor atual do contador
Compara com a máscara final
Se forem iguais, já terminou
Soma máscara com ela própria para a multiplicar por 2
Vai fazer mais um teste com a nova máscara
Se for necessário, pode armazenar o número
de bits a 1 numa célula de memória
Fim do programa
Subtrai os operandos,
mas não armazena
o resultado (atualiza
bits de estado)
Arquitetura de Computadores – Funcionamento básico de um computador
52
Banco de registos do PEPE-16
15
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
José Delgado © 2012
8 7
0
RL
SP
RE
BTE
TEMP
Arquitetura de Computadores – Funcionamento básico de um computador
53
A ilusão de memórias separadas
instruções
endereços
de instruções
Núcleo do
processador
dados
dados
endereços
Interface
de
memória
dados/instruções
Memória
principal
(dados e
instruções)
endereços
de dados
Processador
• As memórias comerciais só têm uma ligação de dados
bidireccional (para poupar pinos e reduzir o custo)
• O núcleo do processador “vê” quatro ligações
unidirecionais.
• A interface de memória arbitra e coordena os acessos.
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
54
PEPE-8: processador de
instruções uniciclo
endereço de
instruções
Memória de
instruções
Memória
de dados
endereço de dados
PC
WR
SEL_A
MUX
ESCR_A
Registo A
1.º operando 2.º operando
SEL_ALU
ALU
resultado da operação
• O PEPE-8 executa as instruções num só ciclo de relógio,
mas exige ligações à memória separadas.
• Parece rápido, mas não é bem assim (a frequência de
relógio é limitada pela operação mais lenta!). A sua
grande vantagem é ser simples.
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
55
PEPE-16: processador de
instruções multi-ciclo
Processador
Unidade de
dados
•
•
Bus de endereços
Interface de
memória
Unidade de
controlo
Bus de controlo
Bus de dados
O PEPE-16 já pode usar as memórias comerciais.
Cada instrução tem de demorar vários ciclos de relógio (de
frequência mais elevada).
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
56
Estrutura
de um processador
Função
Saída (F)
CLK
R8
R9
R10
R11
R12
R13
R14
R15
José Delgado © 2012
F
flags
RL
SP
RE
BTE
TEMP
dados/instr.
Interface de memória
000
A
Unidade de
Unidade
001 de A + B
Máquina
dedeestados
Banco
processamento
controlo
010
A-B
de dadosentradas
registos
PC
relógio
Circuito
011
A + B + carry Registo
saídas
de
estado
combinatório
Registo de
100
A+1
Bits deinstrução
estado:
15
8 7
0
MPX
101R0 A  B
Bus end.
Z – Zero
endereços
C – Transporte
110R1 A(carry)
B
dados
A
R2
B
N – Negativo
111R3 A  B
Bus dados
O – Excesso
(overflow)
R4
Unidade
Controlo
R5
aritmética e
O N C Z
R6
lógica (ALU)
R7
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
57
Operação entre registos
Unidade de
controlo
PC
Banco de
registos
MPX
A
dados
B
F
CLK
flags
dados/instr.
de memória
Unidade
aritmética e
lógica (ALU)
Controlo
José Delgado © 2012
endereços
Interface
Registo de
instrução
Unidade
de
R1

R1
processamento
de dados
+ R2
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
58
Operação entre registos
Tudo ocorre em 2 ciclos de relógio:
1.
2.
Bits de estado:
Bus dados
Unidade
Z – Zero
C – Transporte
(carry)
aritmética
e
– Negativo
lógicaN(ALU)
O F– Excesso (overflow)Bus contr.
Controlo
CLK
flags
José Delgado © 2012
Interface de memória
Unidade de controlo especifica
registos (A, B, destino), função
Unidade
de
da
ALU, seleção
dos
controlo flags a atualizar
multiplexers,
PC
Registo destino e flags são
atualizadas
Registo de
instrução
Função
Saída (F)
000
A
001
A +Unidade
B
R1  de
R1 + R2
010
A
B
Banco de
processamento
de
registos
011Banco
A +de
B +dados
carry
100 registos
A+1
101
AB
15
8 7
0
MPX
Bus end.
110 endereços
AB
R0
R1
111
AB
R2 A
dados
B
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
dados/instr.
MPX
O
RL N C Z
SP
RE
BTE
TEMP
Arquitetura de Computadores – Funcionamento básico de um computador
59
Leitura da memória
Banco de
registos
MPX
A
endereços
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
Unidade
R3 deM[R1]
processamento
de dados
dados/instr.
Interface de memória
• SãoUnidade
os sinaisde
que vêm da
unidade
de controlo que
controlo
comandam tudo o que acontece.
PC
• É como se os dados fossem
água. Para
a encaminhar
basta
Registo
de
abrir e fechar
comportas.
instrução
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
60
Escrita na memória
Banco de
registos
MPX
A
endereços
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
Unidade
de
M[R2]
processamento
de dados
dados/instr.
Interface de memória
• SãoUnidade
os sinaisde
que vêm da
unidade
de controlo que
controlo
comandam tudo o que acontece.
PC
• É como se os dados fossem
água. Para
a encaminhar
basta
Registo
de
abrir e fechar
comportas.
instrução
R1
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
61
Busca de instrução (fetch)
Unidade de
controlo
PC
Banco de
registos
MPX
A
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
endereços
dados/instr.
Interface de memória
Registo de
instrução
Unidade de
RI  M[PC]
processamento
PCdados
 PC + 2
de
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
62
Instrução de salto
Unidade de
controlo
PC
Banco de
registos
MPX
A
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
endereços
dados/instr.
Interface de memória
Registo de
instrução
Unidade
PC  de
PC
processamento
de dados
+ R2
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
63
Ciclo do processador
Unidade de
controlo
PC
MPX
A
endereços
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
de dados
dados/instr.
Interface de memória
Registo de
instrução
Banco de
registos
Busca instrução
Descodifica
Busca
operandos
Unidade
de
Executa
(memória)
(registos)
processamento
Escreve resultado
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
64
MOV R2, [R3]
Exemplo
Unidade de
controlo
PC
PC
Banco de
registos
M[R3]
R2  R1
R1
M[R3]
 R1
+ R2
MPX
A
endereços
dados
B
Unidade
aritmética e
lógica (ALU)
Controlo
F
CLK
flags
José Delgado © 2012
MOV [R3], R1
Unidade de
processamento
RI  M[PC]
de dados
PC
 PC + 2
dados/instr.
Interface de memória
Registo de
instrução
ADD R1, R2
Bus end.
Bus dados
Bus contr.
MPX
Arquitetura de Computadores – Funcionamento básico de um computador
65
Exercícios
1. Indique quais os estágios fundamentais do ciclo de
instrução de um processador e a sua finalidade.
2. Sobre o diagrama básico do processador indique
quais as principais operações elementares para ler
da memória e executar as seguintes instruções:
ADD
AND
MOV
MOV
José Delgado © 2012
R1, 1
R1, R2
R2, [R3]
[R1], R2
; R1  R1 + 1
; R1  R1  R2
; R2  M[R3]
; M[R1]  R2
Arquitetura de Computadores – Funcionamento básico de um computador
66
Exercícios (cont.)
3. Um processador efetuou as seguintes operações
elementares:
RI  M[PC]
PC  PC + 2
R1  M[R3]
RI  M[PC]
PC  PC + 2
R2  R2  R1
RI  M[PC]
PC  PC + 2
M[R1]  R2
RI  M[PC]
PC  PC + 2
PC  PC + FFFEH
José Delgado © 2012
a)
b)
c)
Quantas instruções executou nesta
sequência?
Que instruções executou? Basta
descrever com uma frase simples o
que cada instrução faz.
Suponha que o processador (e os
seus registos) são de 16 bits. Diga
qual a instrução que o processador
executará a seguir à última desta
sequência.
Arquitetura de Computadores – Funcionamento básico de um computador
67
Programação do computador
Linguagem
natural
Linguagem
de programação
Linguagem
"...depositar 1000 euros..."
Programador
saldo = saldo + 1000;
Compilador
ADD R1, 1000
assembly
Assemblador
Código máquina
José Delgado © 2012
10011011
Arquitetura de Computadores – Funcionamento básico de um computador
68
Linguagem assembly
conta: ADD
R1, R2
; soma ao saldo
Mnemónica
comentário
Etiqueta 1º operando 2º operando
•
•
•
•
Uma instrução por linha
Formatação rígida
Comentários qb (escritos logo ao fazer o código!)
As instruções refletem diretamente os recursos do
processador
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
69
Comentários das instruções
• Em cada linha, o assembler ignora o caráter “;” e os
que se lhe seguem (até ao fim dessa linha)
• Praticamente todas as linhas de assembly devem ter
comentário, pois a programação é de baixo nível.
• Exemplo:
Comentários
Sem
comentários.
INÚTEIS!
ÚTEIS
O que é isto?!
Saldo:
PLACE 1000H
WORD 0
PLACE 0000H
Deposita: MOV
MOV
MOV
ADD
MOV
...
José Delgado © 2012
R3, 100
R1, Saldo
R2, [R1]
R2, R3
[R1], R2
; Começa
Início da endereços
zona de dados
em 1000H
; variável Saldo inicializada
da conta bancária
a0
; Começa
Início do endereços
programa em 0000H
; Coloca
Valor a depositar
100 em R3
na conta
; Coloca
Endereço
o endereço
da variável
deSaldo
Saldo em R1
; Lê memória
o valor doendereçada
saldo
por R1
; Acrescenta
soma R2 e R3
o valor a depositar ao saldo
; Atualiza
Escreve amemória
variávelendereçada
Saldo
por R1
;...
Arquitetura de Computadores – Funcionamento básico de um computador
70
Classes de instruções
Classe de instruções
Instruções aritméticas
Instruções de bit
Instruções de
transferência de dados
Instruções de controlo
de fluxo
José Delgado © 2012
Descrição e exemplos
Lidam com números em complemento
para 2
ADD, SUB, CMP, MUL, DIV
Lidam com sequências de bits
AND, OR, SET, SHR, ROL
Transferem dados entre dois registos
ou entre um registo e a memória
MOV, SWAP
Controlam a sequência de execução
de instruções, podendo tomar
decisões
JMP, JZ, JNZ, CALL, RET
Arquitetura de Computadores – Funcionamento básico de um computador
71
Registos do processador
15
• Os recursos mais importantes
que as instruções manipulam
são os registos.
• O PEPE tem os seguintes
registos (todos de 16 bits):
– PC (Program Counter);
– 16 registos (R0 a R15), sendo
alguns especiais (a ver mais
tarde)
8 7
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
0
RL
SP
RE
BTE
TEMP
PC
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
72
Bits de estado (flags)
• Fazem parte do Registo de Estado (RE).
• Fornecem indicações sobre o resultado da operação
anterior (nem todas as instruções os alteram).
• Podem influenciar o resultado da operação seguinte.
Bit de estado mais importantes:
(Z) Zero
(C) Transporte (carry)
(V) Excesso (overflow)
(N) Negativo
José Delgado © 2012
Fica a 1 se o resultado de uma
operação:
for zero
tiver transporte
não couber na palavra do
processador
for negativo
Arquitetura de Computadores – Funcionamento básico de um computador
73
Exemplo com o simulador
; Exemplos de instruções simples no PEPE
MOV
MOV
ADD
SUB
R2, 25H
R3, 1234H
R2, R3
R2, R2
; coloca uma constante de um byte no R2
; coloca uma constante de dois bytes no R3
; exemplo de soma
; para dar zero e ver os bits de estado
MOV
ciclo: SUB
JNZ
R4, 5
R4, 1
ciclo
; ilustrar ciclo de 5 iterações
; decrementa contador e afecta bits de estado
; salta se ainda não tiver chegado a 0
SHR
R3, 2
; deslocamento de 2 bits à direita
JMP
fim
; forma expedita de "terminar"
fim:
José Delgado © 2012
Arquitetura de Computadores – Funcionamento básico de um computador
74
Implementar no PEPE
• Objectivo: somar um número com todos os inteiros
positivos menores que ele.
soma = N + (N-1) + (N-2) + . . . + 2 + 1
1.
2.
3.
4.
5.
6.
7.
8.
soma  0
temp  N
Se (temp < 0) salta para 8
Se (temp = 0) salta para 8
soma  soma + temp
temp  temp – 1
Salta para 4
Salta para 8
José Delgado © 2012
(inicializa soma com zero)
(inicializa temp com N)
(se temp for negativo, salta para o fim)
(se temp for zero, salta para o fim)
(adiciona temp a soma)
(decrementa temp)
(salta para o passo 4)
(fim do programa)
Arquitetura de Computadores – Funcionamento básico de um computador
75
Outro exemplo:
contar bits a 1 em 76H
1.
2.
3.
4.
5.
6.
7.
8.
contador  0
máscara  01H
Se (máscara  valor = 0) salta para 5
contador  contador + 1
Se (máscara = 80H) salta para 8
máscara  máscara + máscara
Salta para 3
Salta para 8
posição
em teste
0
1
2
3
4
5
6
7
(inicializa contador de bits a zero)
(inicializa máscara a 0000 0001)
(se o bit está a zero, passa ao próximo)
(bit está a 1, incrementa contador)
(se já testou a última máscara, termina)
(duplica máscara para deslocar bit para a esquerda)
(vai testar o novo bit)
(fim do algoritmo)
Máscara
Valor (76H)
Valor AND máscara
Bit a 1
0000 0001
0000 0010
0000 0100
0000 1000
0001 0000
0010 0000
0100 0000
1000 0000
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0111 0110
0000 0000
0000 0010
0000 0100
0000 0000
0001 0000
0010 0000
0100 0000
0000 0000
Não
Sim
Sim
Não
Sim
Sim
Sim
Não
José Delgado © 2012
Contador
de bits a 1
0
1
2
2
3
4
5
5
Arquitetura de Computadores – Funcionamento básico de um computador
76