AD1 - Organização de Computadores 2023.

1. (2,0 pontos) Em um computador que utiliza a linguagem de montagem

apresentada na aula 4, há quatro valores armazenados na memória, nos
endereços 10, 11, 12 e 13. Faça um programa que realize os seguintes
procedimentos:

i. Verifique qual é o maior desses quatro valores e armazene-o no

endereço 14;

ii. Verifique qual é o menor desses quatro valores e armazene-o no

endereço 15;

iii. Após realizar os passos i e ii, multiplique o valor armazenado no

endereço 14 pelo valor armazenado no endereço 15. Não utilize instruções
de multiplicação para esse procedimento e para os demais
procedimentos de multiplicação desta questão.

Além de apresentar seu programa escrito em linguagem de montagem,

apresente também o programa traduzido para linguagem de máquina. Assuma que
os conteúdos em 10, 11, 12 e 13 já estão armazenados na memória. Considere que
todos os endereços estão em hexadecimal.

2. (2,0 ponto) O seguinte programa em C, traduzido para Assembly usando

https://gcc.godbolt.org/, resolve a questão acima.
1 int main() { 1 main:
2 int a=20, b=21, c=22, d=23; 2 push rbp
3 int min=0, max=0, min1, min2; 3 mov rbp, rsp
4 int max1, max2, resultado; 4 mov DWORD PTR [rbp-12], 20
5 min1=a<b?a:b; 5 mov DWORD PTR [rbp-16], 21
6 min2=c<d?c:d; 6 mov DWORD PTR [rbp-20], 22
7 min=min1<min2?min1:min2; 7 mov DWORD PTR [rbp-24], 23
8 max1=a<b?b:a; 8 mov DWORD PTR [rbp-28], 0
9 max2=c<d?d:c; 9 mov DWORD PTR [rbp-4], 0
10 max=max1<max2?max2:max1; 10 mov edx, DWORD PTR [rbp-16]
11 while (max>0) 11 mov eax, DWORD PTR [rbp-12]
12 { 12 cmp edx, eax
13 resultado=resultado+min; 13 cmovle eax, edx
14 max=max-1; 14 mov DWORD PTR [rbp-32], eax
15 } 15 mov edx, DWORD PTR [rbp-24]
16 } 16 mov eax, DWORD PTR [rbp-20]
17 cmp edx, eax
18 cmovle eax, edx
19 mov DWORD PTR [rbp-36], eax
20 mov edx, DWORD PTR [rbp-36]
21 mov eax, DWORD PTR [rbp-32]
22 cmp edx, eax
23 cmovle eax, edx
24 mov DWORD PTR [rbp-28], eax
25 mov edx, DWORD PTR [rbp-12]
26 mov eax, DWORD PTR [rbp-16]
27 cmp edx, eax
28 cmovge eax, edx
29 mov DWORD PTR [rbp-40], eax
30 mov edx, DWORD PTR [rbp-20]
31 mov eax, DWORD PTR [rbp-24]
32 cmp edx, eax
33 cmovge eax, edx
34 mov DWORD PTR [rbp-44], eax
35 mov edx, DWORD PTR [rbp-40]
36 mov eax, DWORD PTR [rbp-44]
37 cmp edx, eax
38 cmovge eax, edx
39 mov DWORD PTR [rbp-4], eax
40 jmp .L2
41 .L3:
42 mov eax, DWORD PTR [rbp-28]
43 add DWORD PTR [rbp-8], eax
44 sub DWORD PTR [rbp-4], 1
45 .L2:
46 cmp DWORD PTR [rbp-4], 0
47 jg .L3
48 mov eax, 0
49 pop rbp
50 ret
a) (0,5 ponto) Após uma consulta na Internet, descreva brevemente para que
servem os comandos cmovge e cmovle e quais os parâmetros que eles
recebem. Explique por que estes comandos aparecem nas linhas 13, 18, 23,
28, 33 e 38 do programa em Assembly. Estas 6 linhas correspondem a quais
6 linhas do programa em C, respectivamente?
b) (0,5 ponto) As linhas 11 a 15 do programa em C foram traduzidas para quais
linhas do programa em Assembly? Explique detalhadamente o que faz cada
uma das linhas do programa em Assembly correspondentes às linhas 11 a 15
do programa em C.
c) (0,5 ponto) Considere o seguinte programa alternativo em C, que também
resolve o problema da questão anterior. Use https://gcc.godbolt.org/ para
traduzir o programa para Assembly. Este programa, ao ser traduzido para
Assembly, gera mais ou menos comandos que a versão anterior do
programa? Por que? Em particular, quantas vezes a nova versão do
programa faz uso do comando jge em Assembly? Para que serve o comando
jge? Por que a nova versão do programa faz uso de jge e a versão anterior
não?
1 int main() {
2 int a=20, b=21, c=22, d=23;
3 int min=0, max=0, min1, min2;
4 int max1, max2, resultado;
5 if (a<b)
6 {
7 min1=a;
8 max1=b;
9 }
10 else
11 {
12 min1=b;
13 max1=a;
14 }
15 if (c<d)
16 {
17 min2=c;
18 max2=d;
19 }
20 else
21 {
22 min2=d;
23 max2=c;
24 }
25 if (min1<min2)
26 min=min1;
27 else
28 min=min2;
39 if (max1<max2)
30 max=max2;
31 else
32 max=max1;
33 while (max>0)
34 {
35 resultado=resultado+min;
36 max=max-1;
37 }
38 }
d) (0,5 ponto) Considere o seguinte programa alternativo adicional em C, que
também resolve o problema da questão anterior. Usamos
https://gcc.godbolt.org/ para traduzir o programa para Assembly. Este
programa, ao ser traduzido para Assembly, gera mais ou menos comandos
que as versões anteriores do programa? Por que? Em particular, quantas
vezes a nova versão do programa faz uso do comando jnb em Assembly?
Para que serve o comando jnb? Por que a nova versão do programa faz uso
de jnb e a versão anterior não? Indique, para cada uma das linhas de 7 a 13
do programa em C, quais as linhas em Assembly correspondentes?
1 int main() { 1 main:
2 unsigned int vect[4]= 2 push rbp
3 {20, 21, 22, 23}; 3 mov rbp, rsp
4 unsigned int i=0, min=1000; 4 mov DWORD PTR [rbp-32], 20
5 unsigned int max=0; 5 mov DWORD PTR [rbp-28], 21
6 unsigned int resultado; 6 mov DWORD PTR [rbp-24], 22
7 while (i<5) 7 mov DWORD PTR [rbp-20], 23
8 { 8 mov DWORD PTR [rbp-4], 0
9 if (vect[i]<min) 9 mov DWORD PTR [rbp-8], 1000
10 min=vect[i]; 10 mov DWORD PTR [rbp-12], 0
11 if (vect[i]>max) 11 jmp .L2
12 max=vect[i]; 12 .L5:
13 i++; 13 mov eax, DWORD PTR [rbp-4]
14 } 14 mov eax, DWORD PTR [rbp-32+rax*4]
15 while (max>0) 15 cmp eax, DWORD PTR [rbp-8]
16 { 16 jnb .L3
17 resultado=resultado+min; 17 mov eax, DWORD PTR [rbp-4]
18 max=max-1; 18 mov eax, DWORD PTR [rbp-32+rax*4]
19 } 19 mov DWORD PTR [rbp-8], eax
20 } 20 .L3:
21 mov eax, DWORD PTR [rbp-4]
22 mov eax, DWORD PTR [rbp-32+rax*4]
23 cmp DWORD PTR [rbp-12], eax
24 jnb .L4
25 mov eax, DWORD PTR [rbp-4]
26 mov eax, DWORD PTR [rbp-32+rax*4]
27 mov DWORD PTR [rbp-12], eax
28 .L4:
29 add DWORD PTR [rbp-4], 1
30 .L2:
31 cmp DWORD PTR [rbp-4], 4
32 jbe .L5
33 jmp .L6
34 .L7:
35 mov eax, DWORD PTR [rbp-8]
36 add DWORD PTR [rbp-16], eax
37 sub DWORD PTR [rbp-12], 1
38 .L6:
39 cmp DWORD PTR [rbp-12], 0
40 jne .L7
41 mov eax, 0
42 pop rbp
43 ret
3. (1,0 ponto) Lembre-se que o processamento de uma instrução de máquina
envolve os seguintes elementos, que constituem o ciclo de instrução da UCP.
Esses elementos são repetidos continuamente, ciclicamente:

I. Busca
II. Interpretação e decodificação
III. Execução final

Explique detalhadamente todos os passos para a execução das seguintes

instruções:

a) (0,75 ponto) STR Op.

b) (0,75 ponto) ADD Op.

Ao elaborar sua resposta indique, para cada um dos passos para a execução
das instruções, a qual dos elementos, de I a III, ele corresponde.

4. (2,0 pontos) Considere uma máquina com relógio com freqüência de 6 GHZ.
a) (0,75 ponto) Calcule o tempo para executar um programa com 10
instruções, considerando que cada instrução é executada em 6 ciclos de
relógio e a execução de uma instrução só se inicia quando a execução da
instrução anterior é finalizada.
b) (0,75 ponto) Uma nova implementação dessa máquina utiliza um pipeline
de 5 estágios, todos de duração igual a 1 ciclo de relógio. A execução de
cada instrução corresponde a 5 estágios. Assuma que, quando a máquina
utiliza pipeline, é necessário executar três instruções extras, de
inicialização do pipeline, e que cada uma dessas instruções tem duração
de 2 estágios. Assuma também que essas instruções são executadas de
forma sequencial, ou seja, cada instrução de inicialização é executada em
dois ciclos de relógio e a execução de uma instrução de inicialização só
se inicia quando a execução da instrução anterior é finalizada. Calcule o
tempo para executar o programa do item a.
c) (0,50 ponto) Calcule o mínimo de instruções que um programa deve ter
para que o tempo de execução do programa com o pipeline do item b seja
menor ou igual ao tempo da máquina sem pipeline do item a.
4. (1,5 pontos) O conceito de cache utilizado em UCPs pode ser extrapolado para
diversos componentes de sistemas computacionais. Faça uma pesquisa sobre CDNs
(Content Delivery Networks) e responda os seguintes itens.
a) (0,75 ponto) Explique como as CDNs utilizam o conceito de cache.
b) (0,75 ponto) Descreva a hierarquia de memória abordada no curso e
posicione o armazenamento das CDNs nessa hierarquia.
5. (1,5 pontos) Considere uma máquina com 256 Mega células de memória na qual
cada célula armazena uma palavra e cada instrução tem o tamanho de uma palavra.
Esta máquina possui um conjunto de instruções com 512 instruções distintas, sendo
cada uma delas composta de um código de operação e dois operandos, que indicam
o endereço de memória.
a) Qual o tamanho mínimo do REM?
b) Qual o tamanho mínimo do RI?
c) Qual o tamanho mínimo do RDM?
d) Qual o tamanho da memória em bits?
Se a largura do barramento de dados desta máquina for igual à metade do
tamanho de uma instrução, como funcionará o ciclo de busca?