GABARITO DA AP2

Organização de Computadores 2020.1

1) (2,5) Crie um conjunto de instruções de um operando definidas em Linguagem Assembly, utilizando
endereçamento direto e imediato, necessárias para a realização de operações aritméticas e elabore um programa para
o cálculo da equação abaixo. Ao resolver a questão, explique porque precisamos de instruções de um operando.

i)
Sejam: z o valor imediato;
Y um endereço de memória
ACC o registrador acumulador;

Operações com um operando usando modo direto

ADD Y => (ACC)<-(ACC)+(Y)
SUB Y => (ACC)<-(ACC)-(Y)
MUL Y => (ACC)<-(ACC)*(Y)
DIV Y => (ACC)<-(ACC)/(Y)
LD Y => (ACC)<-(Y)
STR Y => (Y)<-(ACC)

Operações com um operando usando valor imediato (modo imediato)

ADDi z => (ACC)<-(ACC) + z
SUBi z => (ACC)<-(ACC) - z
MULi z => (ACC)<-(ACC) * z
DIVi z => (ACC)<-(ACC) / z

OBS1: Como cada instrução tem um código de operação diferente, seus mnemônicos (nomes) em assembly também deverão ser
diferentes, Foi adotado o acréscimo do sufixo “I” para as operações que utilizam modo imediato. A escolha deste sufixo não é regra,
cada fabricante de processador define sua forma de nomear e diferenciar as instruções de sua arquitetura.

Solução para a expressão:

X = C * ( (D + 5) / B - 5)

LD D => (ACC) <- (D)

ADDi 5 => (ACC) <- (ACC) + 5
DIV B => (ACC) <- (ACC) / (B)
SUBi 5 => (ACC) <- (ACC) – 5
MUL C => (ACC) <- (ACC) * (C)
STR X => (X) <- (ACC)

ii) Operações com um operando costumam ser menores (quantidade de bits), mais rápida a decodificação e
execução.
Processadores que trabalhem apenas com instruções de um operando são mais simples, de custo menor,
entretanto, os programas com esse tipo de instrução são bem maiores (uma maior quantidade de instruções)
do que programas que utilizem instruções com dois ou mais operandos.
2) (2,5) Considere o seguinte conjunto de 32 bits representado em hexadecimal (D408D000)16. Indique o valor em
decimal (deixe as contas indicadas) para este conjunto de bits, quando considerarmos que ele está representando:

(D408D000)16 = (1101 0100 0000 1000 1101 0000 0000 0000 )2

101 0100 0000 1000 1101 0000 0000 0000

a) (0,6) um inteiro sem sinal.
231 + 230 + 228 + 226 + 219 + 215 + 214 +
212 = 3.557.347.328

b) (0,6) um inteiro representado em sinal e magnitude.

- ( 230 + 228 + 226 + 219 + 215 + 214 +
212 ) = - 1.409.863.680

c) (0,6) um inteiro em complemento a 2.

- 231 + ( 230 + 228 + 226 + 219 + 215 + 214 +
212 ) = - 737.619.968

d) (0,7) um número em ponto flutuante que utiliza a representação padrão IEEE 754 para precisão simples,
ou seja, um bit para o sinal (0 para positivos e 1 para negativos), 8 bits para o expoente representado em
excesso de 127 e 23 bits para a parte fracionária. Os números a serem representados devem estar no
seguinte formato:

N = +/-(1,b-1b-2b-3...b-m) × 2Expoente.

1101 0100 0000 1000 1101 0000 0000 0000 2

Temos então:
Sinal = 1 (negativo)
Expoente = 101 0100 0 (excesso 127) = 27 + 25 + 23 =
Mantissa = , 01100100002
Normalizado: -1,0110010000 x 2-13
= - ( 2-13 + 2-15 +2-16 +2-19 ) = - 0,000169754

e) (0) Suponha que o valor corresponda a uma operação bancária (depósito é positivo, e saque é negativo).
Um programador se confunde e lê o conjunto de bits como se fosse um inteiro representado em sinal e
magnitude, quando na realidade ele é um inteiro sem sinal. O que deveria ocorrer na conta do cliente? E
o que acaba ocorrendo? Discuta os possíveis problemas que podem ocorrer quando programadores se
confundem nos tipos de dados.

Há uma inconsistência na questão pois não seria possível representar números negativos (necessários
para saques) com inteiro sem sinal. Assim, a primeira parte do item geraria respostas divergentes.

Entretanto, podemos analisar as consequências quando programadores se confundem nos tipos de

dados. Por exemplo, se um padrão adotado é complemento a 2 e o programador entender (e programar)
por excesso, teremos uma inversão nas operações, por exemplo, quando fornecer um valor negativo
(desejando um saque) será feita um depósito e o oposto quanto fornecer um valor positivo. Visto que um
numero na representação de complemento a 2 tem o sinal inverso ao mesmo número na representação
por excesso quando convertido para a base 10. O módulo desse valor (desconsiderando o sinal) na base
10 também difere em ambas representações, desta forma, a magnitude (valor) operado também é
diferente independente da operação.

OBS: os pontos desse item foram redistribuídos pelos outros 4 anteriores.

3) (2,0) Informe se é Verdadeiro (V) ou Falso (F), justificando quando for Falso, as seguintes sentenças:

a) A interpretação é mais vantajosa em relação à compilação, pois na interpretação o programa é totalmente

traduzido para linguagem de máquina antes da execução gerando um código objeto.
Falso, é na compilação que o programa é totalmente traduzido para a linguagem de máquina antes da
execução

b) Nas arquiteturas SMP, symetric multiprocessors, não há memória compartilhada.

Falso – O SMP é uma arquitetura com vários processadores compartilhando a mesma memória (memória global) sob
controle de um sistema operacional único. Sistemas SMP (ou UMA) têm como característica o acesso a todas as partes
da memória principal com tempo de acesso uniforme.

c) Os clusters de processadores multi-core podem ser classificados como SIMD segundo a classificação de
Flynn.
Falso, os processadores multicore se caracterizam como MIMD

d) Os modos de endereçamento por registrador base e por registrador índice são úteis para realocação de
programas e manipulação de vetores, respectivamente.
Verdadeiro

4) (2,0) Considere um sistema onde o número de ciclos de relógio para realizar uma operação de Entrada/Saída
(E/S) por interrupção seja igual a 100 e o processador utiliza um relógio de 4,0 GHz para executar as instruções.
Determine o overhead (relação entre ciclos de CPU consumidos por segundo pelo processo de E/S e número de
ciclos disponíveis) que ocorre quando se realiza uma operação de E/S com um disco rígido que transfere dados para
o processador em blocos de 64 bytes e possui uma taxa de transferência de 32 MB/segundo.

Taxa de transferência = 32MB/s = 32.000.000 B/seg.

Em cada operação é transferido um bloco de 64 bytes.
A cada segundo ocorrem: 32.000.000B / 64B = 500.000 operações/seg.
Como cada operação leva 100 ciclos.
O total de ciclos consumidos é igual a 500.000 operações/seg x 100ciclos/operação
= 50 x 106 ciclos/seg.
Clock = 4GHz = 4000 x 106 ciclos/seg

O overhead será obtido pela seguinte razão:

= ( 50 x 106 ciclos/seg ) / (4000 x 106 ciclos/seg ) = 0,0125 = 1,25%

5) (1,0) Explique arquiteturas RISC e CISC. Dê exemplos comerciais de cada arquitetura.

RISC: Reduced Instruction Set Computer – Computador com um conjunto reduzido de instruções
CISC - Complex Instruction Set Computer: Computador com um conjunto complexo de instruções

CISC: Principais características:

Possui microprogramação para aumento da quantidade de instruções incluindo novos modos de endereçamento,
de forma a diminuir a complexidade dos compiladores e em consequência permitir linguagens de alto nível com
comandos poderosos para facilitar a vida dos programadores. Em contrapartida, muitas instruções significam muitos bits
em cada código de operação, instrução com maior comprimento e maior tempo de interpretação.

RISC: Principais características:

 Menor quantidade de instruções e tamanho fixo. Não há microprogramação. Permite uma execução otimizada,
mesmo considerando que uma menor quantidade de instruções vá conduzir a programas mais longos. Uma maior
quantidade de registradores e suas utilizações para passagem de parâmetros e recuperação dos dados, permitindo uma
execução mais otimizada de chamada de funções. Menor quantidade de modos de endereçamento com o objetivo da
reduzir de ciclos de relógio para execução das instruções. Instruções de formatos simples e únicos tiram maior proveito
de execução com pipeline cujos estágios consomem o mesmo tempo.
Os processadores Intel e AMD são exemplos de processadores CISC, já o Power PC e o Sparc da Sun (não tão
atuais) são exemplos da arquitetura RISC. Podemos dizer que os processadores atuais são na verdade uma mistura das
duas arquiteturas, implementando em um chip, tirando proveito do que é vantajoso de cada arquitetura.