Solues do Captulo 2

Solues do Captulo 2
2.1
Instruo addi $v0, $zero, 0 lw $v1, 0($a0) sw $v1, 0($a1) addi $a0, $a0, 4 addi $a1, $a1, 4 beq $v1, $zero, loop Formato I I I I I I op 8 35 43 8 8 4 rs 0 4 5 4 5 3 rt 2 3 3 4 5 0 imediato 0 0 0 4 4 5

2.5 O cdigo carrega a instruo sll, que estava em shifter para um registrador, e mascara o valor deslocado, colocando os 5 bits menos significativos de $s2 em seu lugar. Depois, ele escreve a ins-

truo de volta na memria e prossegue para execut-la. O cdigo automodificvel; assim, ele muito difcil de depurar e, provavelmente, proibido em muitos sistemas operacionais modernos. Um problema importante que estaramos escrevendo na cache de instrues, e isso claramente atrasa as coisas e exigiria uma grande quantidade de trabalho a ser implementado corretamente (ver Captulos 6 e 7).
2.7 A nova instruo trata $s0 e $s1 como um par de registradores e realiza um deslocamento no qual o bit menos significativo de $s0 se torna o bit mais significativo de $s1, e tanto $s0 quanto $s1

so deslocados para a direita de uma posio.

2.9 O loop C while (save [i] == k) i += 1;

com i e k correspondendo aos registradores $s3 e $s5 e a base do array save em $s6. O cdigo assembly dado no exemplo Cdigo antes
Loop: sll add lw bne addi j Exit: $t1, $t1, $t0, $t0, $s3, Loop $s3, 2 # $t1, $s6 # 0($t1) # $s5, Exit # $s3, 1 # # Reg $t1 Reg vai i = vai temp $t1 = 4 * i = endereo de save [i] temp $t0 = save[i] para Exit se save[i] k i + 1 para Loop

O nmero de instrues executadas se save[i + m] no for igual a k para m = 10 e no for igual a k para 0 m 9, 10 6 + 4 = 64, o que corresponde a 10 iteraes completas do loop mais uma passada final, que vai para Exit na instruo bne antes de atualizar i. A reescrita direta para usar no mximo um desvio no loop gera Cdigo depois
sll add lw bne Loop: addi sll $t1, $t1, $t0, $t0, $s3, $t1, $s3, 2 $t1, $s6 0($t1) $s5, Exit $s3, 1 $s3, 2 # # # # # # Reg $t1 Reg vai i = Reg temp $t1 = 4 * i = endereo de save[i] temp $t0 = save[i] para Exit se save[i] k i + 1 temp $t1 = 4 * i

Organizao e Projeto de Computadores

ELSEVIER

add lw beq Exit:

$t1, $t1, $s6 # $t1 = endereo de save[i] $t0, 0($t1) # Reg temp $t0 = save[i] $t0, $s5, Loop # vai para Loop se save[i] = k

A quantidade de instrues executadas por essa nova forma de loop igual a 4 + 10 5 = 54. Se $t1 for incrementado por quatro dentro do loop, ento possvel que haja uma economia maior no corpo do loop. Cdigo aps mais melhoria
sll add lw bne Loop: addi add lw beq Exit: $t1, $t1, $t0, $t0, $s3, $t1, $t0, $t0, $s3, 2 $t1, $s6 0($t1) $s5, Exit $s3, 1 $t1, 4 0($t1) $s5, Loop # # # # # # # # Reg $t1 Reg vai i = $t1 Reg vai temp $t1 = 4 * i = endereo de save[i] temp $t0 = save[i] para Exit se save[i] k i + 1 = endereo de save[i] temp $t0 = save[i] para Loop se save[i] = k

A quantidade de instrues executadas agora igual a 4 + 10 4 = 44.

2.13 Nenhuma soluo fornecida. 2.14 Nenhuma soluo fornecida. 2.15 Nenhuma soluo fornecida. 2.16 Aqui est o cdigo para itoa, tirado de A Linguagem de Programao C, de Kernighan e

Ritchie:
void reverse( char *s ) { int c, i, j; for( i = 0, j = strlen(s)1; i < j; i++, j ) { c=s[i]; s[i]=s[j]; s[j] = c; } } void itoa( int n, char *s ) { int i, sign; if( ( sign = n ) < 0 ) n = n; i = 0; do { s[i++] = n % 10 + '0'; } while( ( n /= 10 ) > 0 ); if( sign < 0 ) s[i++] = ''; s[i] = '\0'; reverse( s ); } }

Solues do Captulo 2

O cdigo assembly do MIPS, junto com a rotina principal para test-lo, seria algo como:
.data hello:.ascii "\nEntre com um numero:" newln:.asciiz "\n" str:.space 32 .text reverse: # # # #

Espera a string a ser invertida em $a0 s = i = $a0 j = $t2 $a0, 1 1($t2) end_strlen $t2, 1 1($t2) strlen_loop # j = s 1; # while( *(j+1) )

addi $t2, lbu $t3, beqz $t3, strlen_loop: addi $t2, lbu $t3, bnez $t3, end_strlen:

# j++;

# agora j = # &s[strlen(s)1] bge $a0, $t2, end_reverse # while( i < j ) # { reverse_loop: lbu $t3, ($a0) # $t3 = *i; lbu $t4, ($t2) # $t4 = *j; sb $t3, ($t2) # *j = $t3; sb $t4, ($a0) # *i = $t4; addi $a0, $a0, 1 # i++; addi $t2, $t2, 1 # j--; blt $a0, $t2, reverse_loop # } end_reverse: jr $31 .globl itoa itoa:addi $29, $29, 4 sw $31, 0($29) move $t0, $a0 move $t3, $a1 bgez $a0, non_neg sub $a0, $0, $a0 non_neg: li $t2, 10 itoa_loop: div $a0, $t2 # hi = n % 10; mfhi mflo addi $t1 $a0 $t1, # '0' + sb $t1, addi $a1, bnez $a0, bgez $t0, # $a0 = n # $a1 = s # # # # sign = n; $t3 = s; if( sign < 0 ) n = n

# do { # lo = n / 10;

$t1, 48 n % 10; 0($a1) $a1, 1 itoa_loop non_neg2

# n /= 10; # $t1 = # # # # *s = $t1; s++; } while( n ); if( sign < 0 )

Solues do Captulo 2

ELSEVIER

# { li $t1, '' sb $t1, 0($a1) addi $a1, $a1, 1 non_neg2: sb $0, 0($a1) move $a0, $t3 jal reverse lw $31, 0($29) addi $29, $29, 4 jr $31 .globl main main:addi $29, sw $31, li $v0, la $a0, syscall li $v0, syscall move $a0, la $a1, jal itoa la $a0, li $v0, syscall la $a0, syscall lw $31, addi $29, jr $31

# *s = ''; # s++; # }

# reverse( s );

$29, 4 0($29) 4 hello 5 $v0 str str 4 newln 0($29) $29, 4 # read_int # itoa( $a0, str ); # #

Um problema comum que ocorreu foi tratar a string como uma srie de words, em vez de trat-la como uma srie de bytes. Cada caracter em uma string um byte. Um byte zero termina uma string. Assim, quando as pessoas armazenavam cdigos ASCII um por palavra e depois tentavam usar a chamada ao sistema print_str, somente o primeiro caracter do nmero era impresso.
2.17 F 2.18 Nenhuma falsa; todas so verdadeiras. 2.19 D 2.20. E 2.25 O endereo base de x, em binrio, 0000 0000 0110 0001 1010 1000 0000 0000, implicando que temos que usar lui: lui ori lw add sw 2.27 count = 1; do { temp = *source; $t0, $t0, $t1, $t1, $t1, 0000 0000 0110 0001 # carrega endereo de x em $t0 $t0, 1010 1000 0000 0000 20($t0) # $t1 = Memria[20 + $t0] $t1, $t3 # $t1 = x[5] + a 16($t0) # x[4] = x[5] + a

Solues do Captulo 2

count = count + 1; *destination = temp; source = source + 1; destination = destination + 1; } while (temp != 0); 2.28 O fragmento de cdigo C for (i=0; i<=100; i=i+1) {a[i] = b[i] + c;}

com os arrays de words a e b nos endereos base $a0 e $a1, respectivamente. Primeiro, inicialize i com 0, com i mantido em $t0:
add $t0, $zero, $zero # Reg temp $t0 = 0

Considere que $s0 contm o endereo de c (se $s0 for manter o valor de c, omita a instruo seguinte):
lw $t1, 0($s0) # Reg temp $t1 = c

Para calcular o endereo em bytes de elementos sucessivos do array e para testar o trmino do loop, as constantes 4 e 401 so necessrias. Assuma que elas so colocadas na memria quando o programa carregado:
lw $t2, AddressConstant4($zero) lw $t3, AddressConstant401($zero) # Reg temp $t2 = 4 # Reg temp $t3 = 401

As instrues addi (add immediate) e slti (set less than immediate) podem possuir constantes em sua representao de cdigo de mquina, economizando uma instruo load e o uso de um registrador. Agora, o corpo do loop acessa os elementos do array, realiza o clculo e testa o trmino:
Loop: add $t4, $a1, $t0 lw $t5, 0($t4) add $t6, $t5, $t1 # Reg temp $t4 = endereo de b[i] # Reg temp $t5 = b[i] # Reg temp $t6 = b[i] + c

Essa instruo add seria add $t6, $t5, $s0, se fosse assumido que $s0 mantm o valor de c. Continuando o loop:
add $t7, $a0, $t0 sw $t6, 0($t7) add $t0, $t0, $t2 slt $t8, $t0, $t3 bne $t8, $zero, Loop # # # # # Reg temp $t7 = endereo de a[i] a[i] = b[i] + c i = i + 4 $t8 = 1 if $t0 < 401, ou seja, i 100 vai para Loop se i 100

O nmero de instrues executadas igual a 4 + 101 8 = 812. O nmero de referncias de dados feitas 3 + 101 2 = 205.
2.31 B 2.32 Todas so pseudoinstrues: i. 40.000 > +32.767 => lui, ori. ii. beq: Ambos precisam ser registradores. Sada: se > 215, ento pseudo. iii. sub: Ambos precisam ser registradores. Mesmo que fosse subi, no existe subi no MIPS; isso geraria addi $t0,$t1, 1; 2.33 a, b e c. a e b poderiam formar uma referncia de dados, de modo que podem ser realocados. c uma sub-rotina, de modo que pode ser realocada. d est correto j que relativo ao PC. 2.35 O programa tem n instrues.

O tempo de ciclo de clock original t. N o percentual de loads remanescentes.

Solues do Captulo 2

ELSEVIER

execant = n CPI t execnovo = (0,76 n + N 0,24 n) CPI 1,1t execnovo execant (0,76 n + N 0,24 n) CPI 1,1t n CPI t (0,76 n + N 0,24 n) 1,1 n (0,76 + N 0,24) 1,1 1 0,76 + N 0,24 11 ,1 N 0,24 N
1 1,1 1 1,1

0,76

- 0,76

0,24 1 - 11 , 0,76 N 11 , 0,24 N = 0,62

Precisamos eliminar pelo menos 38% dos loads.

2.36 Nenhuma soluo fornecida.

Solues do Captulo 3

Solues do Captulo 3
3.8 preciso suspeitar das duas afirmaes. Um exame simples gera

6=2+4 12 = 4 + 8 18 = 2 + 16 24 = 8 + 16 30 = 2 + 4 + 8 + 16 (assim, sabemos que Harry est errado). 36 = 4 + 32 42 = 2 + 8 + 32 (assim, sabemos que David est errado).
3.11 subu sltu add sub $t3, $t2, $t2, $t2, $t5, $t5, $t6, $t4, $t7 $t7 $t2 $t2

sem sinal
subu sltu addu subu 3.14 $t3, $t2, $t2, $t2, $t5, $t5, $t6, $t4, $t7 $t7 $t2 $t2

<<Esta soluo destri o valor de $s0>>

addu sll addu $s1, $s0, $zero $s0, $s0, 3 $s1, $s1, $s0

<<Esta soluo preserva $s0>>

addu sll addu $s1, $s0, $zero $t0, $s0, 3 $s1, $s1, $t0

3.15 Nenhuma soluo fornecida. 3.16 Nenhuma soluo fornecida. 3.17 Nenhuma soluo fornecida. 3.18 C1 = c4, C2 = c8, C3 = c12 e C4 = c16.

c4 = G3,0 + (P3,0c0). c8 dado neste exerccio. c12 = G11,8 + (P11,8 G7,4) + (P11,8P7,4G3,0) + (P11,8P7,4P3,0c0). c16 = G15,12 + (P15,12G11,8) + (P15,12P11,8G7,4) + (P15,12P11,8P7,4G3,0) + (P15,12P11,8P7,4P3,0c0).
3.19 As equaes para c4, c8 e c12 so iguais quelas dadas na soluo do Exerccio 3.18. O uso de somadores de 16 bits significa o uso de outro nvel de lgica carry-lookahead para construir o somador de 64 bits. O segundo nvel de gerao, G0, e propagao, P0', so:

G0' = G15,0 = G15,12 + P15,12 G11,8 + P15,12 P11,8 G7,4 + P15,12 P11,8 P7,4 G3,0 e P0' = P15,0 = P15,12 P11,8 P7,4 P3,0

Solues do Captulo 3

ELSEVIER

Usando G0' e P0', podemos escrever c16 de forma mais compacta como c16 = G15,0 + P15,0 c0 e c32 = G31,16 + P31,16 c16 c48 = G47,32 + P47,32 c32 c64 = G63,48 + P63,48 c48 Um diagrama de somador de 64 bits no estilo da figura a seguir, se pareceria com isto:

CarryIn a0, b0, Result015

1 5

ALU0
1 5

P15, 0 G15, 0
c16
Unidade de carry-loookahead de segundo nvel

CarryIn a16, 31 ALU1 b16,

3 1

Result1631 P31, G31, c32 CarryIn

1 6 1 6

a32, b32,

Result3247
4 7

ALU2
4 7

P47, G47, c48

3 2 3 2

CarryIn a48, b48, Result4863

6 3

ALU3
6 3

P63, G63,

4 8 4 8

c64 CarryOut

3.20 Nenhuma soluo fornecida. 3.21 Nenhuma soluo fornecida. 3.22 Nenhuma soluo fornecida. 3.23 Nenhuma soluo fornecida. 3.29 #include <stdio.h> void main(void) { double d; scanf("%lf",&d); printf("%llx\n",d); }

Solues do Captulo 3

3.30 import java.io.*; public class FloatingConvert { public static void main(String[ ] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String line = in.readLine( ); if(line != null) { double d = Double.parseDouble(line); System.out.println(Long.toHexString(Double.doubleToLongBits(d))); } } } 3.31 # multiplica por 4 somando 2 ao expoente; # ignora o overflow e os valores especiais dos expoentes lw $t0, X($zero) beq $t0, $zero, Exit lui $t1, 0x01000000 add $t0, $t0, $t1 sw $t0, X(zero) Exit: 3.44 Nenhuma soluo fornecida. 3.45 O bit de guarda est presente para preservar a preciso total (nmero de bits significativos) do # # # # # $t0 = prec. simples valor pf mp muda se zero constante 2 no campo exp. soma ao expoente substitui

significando durante a operao. Pode ser mostrado que um nico bit suficiente para +, , e /, para preservar a preciso de um resultado que pode ser expresso no nmero de bits disponveis no significando. Se o resultado tiver mais bits de preciso do que o disponvel no formato de ponto flutuante, ento o arredondamento usado para gerar uma aproximao exprimvel (encaixa no nmero de bits disponvel) do resultado. Os bits guard (g), round (r) e sticky (s) participam nos deslocamentos do significando direita, para fazer com que o expoente do nmero menor combine com o do nmero maior. O deslocamento direita move o LSB para g, g para r, e o OR do(s) bit(s) deslocado(s) de r para s. Durante os deslocamentos esquerda, s no participa, zeros so deslocados para r conforme a necessidade, r se desloca para g, e g se desloca para o LSB (bit menos significativo). As tabelas a seguir listam as aes necessrias para cada modo de arredondamento. Arredondamento para infinito negativo:
g R s Ao

0 X

0 X

0 1

Resultado exato; significando arredondado corretamente Resultado inexato, arredondado corretamente se Sum for positivo, arredonda somando 1 ao LSB, se Sum for negativo (torna Sum mais negativo, movendo-o para infinito negativo) Resultado inexato, arredondado corretamente se Sum for positivo, arredonda somando 1 ao LSB, se Sum for negativo (torna Sum mais negativo, movendo-o para infinito negativo) Resultado inexato, arredondado corretamente se Sum for positivo, arredonda somando 1 ao LSB, se Sum for negativo (torna Sum mais negativo, movendo-o para infinito negativo)

Solues do Captulo 3

ELSEVIER

Arredondamento para infinito positivo:

g R s Ao

0 X

0 X

0 1

Resultado exato; significando arredondado corretamente Resultado inexato, arredondado corretamente se Sum for negativo, arredonda somando 1 ao LSB, se Sum for positivo (torna Sum mais positivo, movendo-o para infinito positivo) Resultado inexato, arredondado corretamente se Sum for negativo, arredonda somando 1 ao LSB, se Sum for positivo (torna Sum mais positivo, movendo-o para infinito positivo) Resultado inexato, arredondado corretamente se Sum for negativo, arredonda somando 1 ao LSB, se Sum for positivo (torna Sum mais positivo, movendo-o para infinito positivo)

Truncamento:
g R s Ao

Significando arredondado corretamente

Arredondado ao mais prximo (no-influenciado):

Sump G r s Ao

X X X 0 1 X X

0 0 0 1 1 1 1

0 X 1 0 0 1 X

0 1 0 0 0 X 1

Resultado exato; significando arredondado corretamente Resultado inexato, mas significando arredondado corretamente Resultado inexato, mas significando arredondado corretamente Empate com significando par; significando correto Empate com significando mpar; arredonda para o par mais prximo somando 1 ao LSB Resultado inexato; arredonda para o mais prximo somando 1 ao LSB Resultado inexato; arredonda para o mais prximo somando 1 ao LSB

Observe que o arredondamento no influenciado para o mais prximo o nico modo que exige o valor do LSB. Nem o arredondamento no-influenciado para o mais prximo nem o truncamento prevem sua ao sobre o sinal do significando. O arredondamento para mais ou menos infinito so os nicos modos que exigem o bit de sinal. Preenchendo a tabela dada no exerccio:
Modo de arredondamento Sum 0 Sum < 0

Em direo a 8 Em direo a +8 Truncado Par mais prximo

vazio OR(g,r,s) vazio g (Sump + r + s)

OR(g,r,s) vazio vazio g (Sump + r + s)

3.46 Nenhuma soluo fornecida.

Solues do Captulo 3

3.47
1 2 3 4 4 6 7 8 8 8 lw addiu sw addu or beq bne subu andi nor 24% 12% 9% 7% 7% 6% 5% 3% 3% 3%

3.48
1 2 2 4 4 6 7 8 9 9 9 9 9 addu lw l.d add.d mul.d s.d lui sub.d addiu subu or sw beq 21% 15% 15% 8% 8% 7% 5% 3% 2% 2% 2% 2% 2%

3.49

a. lw, addiu, sw, addu, or, beq, subu b. 68% c. 79% d. 46% e. 92%
3.50 lw, addiu, addu, l.d, sw lw, addiu, addu, sw so as mais importantes com % combinada. l.d muito importante para benchmarks de PF.

Solues do Captulo 3

ELSEVIER

3.51 Operaes de 1,0 ciclo (que no esto na Figura 3.11.1) e suas porcentagens:
addu addiu subu and andi or ori nor sll lui slt slti sltu sltiu sra misc 49% 7 12 3 1 3 7 2 3 1 2 2 1 1 1 1 2

Operaes de 1,3 ciclos (loads e stores) e suas porcentagens:

lw 24 9 1 1 1

sw
lbu sb

lhu
36%

Operaes de 1,6 ciclos (desvios condicionais) e suas porcentagens:

beq bne bltz bgez 13% 6 5 1 1

Operaes de 1,2 ciclos (jumps) e suas porcentagens:

jal jr 2% 1 1

Mdia: 0,49 + 1,3 * 0,36 + 1,6 * 0,13 + 1,2 * 0,02 = 1,19 CPI

Solues do Captulo 3

3.52 Operaes de 1,0 ciclo (que no esto na Figura 3.11.1) e suas porcentagens:
addu addiu subu or nor sll lui misc 37% 21 2 2 2 1 1 5 3

Operaes de 1,3 ciclos (loads e stores) e suas porcentagens:

lw sw l.s s.s 39% 15 2 15 7

Operaes de 1,6 ciclos (desvios condicionais) e suas porcentagens:

beq bne blez 4% 2 1 1

Operaes de 1,0 ciclos (soma PF) e suas porcentagens:

add.d sub.d 11% 8 3

3.0 mul FP 8% 5.0 mul Int 1% Mdia: 0,37 + 1,3 * 0,39 + 1,6 * 0,04 + 0,11 + 3,0 * 0,08 + 5,0 * 0,01 = 1,341 CPI

Solues do Captulo 4

Solues do Captulo 4
4.4 Queremos maximizar a taxa de processamento enquanto minimizamos o custo total exigido

para fazer isso. Portanto, estamos mais interessados no custo por vazo unitria. primeira vista, pode parecer razovel que (Custo/Vazo) = (Custo/(1 execuo do programa 1/Tempo de execuo)) = (Custo * Tempo de execuo)/(1 execuo do programa 1) seja um modelo equivalente a isso. Porm, isso falha quando pensamos nas mquinas que podem executar vrios programas simultaneamente. Considere o caso onde a mquina M pode executar 3 instncias do programa 1 simultaneamente, mas leva o dobro do tempo para que a mquina M' de mesmo preo, que s pode executar 1 programa de cada vez. Ento, por (Custo * Tempo de execuo), M' pareceria melhor, mas M tem 50% mais vazo do que M'.
4.5 M1 leva 7,0 segundos no total, e M2 leva 11,5 segundos no total. Assim, M1 11,5/7,0 = 1,64

vezes mais rpido. A razo de custos de 800/500 = 1,60. Portanto, M1 mais econmico, pois consegue um aumento de desempenho de 1,64 para uma diminuio de custo de 1,6.
4.19 MIPS =

velocidade de clock CPI 10 6

. Vamos encontrar o CPI para um MFP primeiro.

CPI para MFP = 0,1 6 + 0,15 4 + 0,05 20 + 0,7 2 = 3,6 naturalmente, o CPI para MNFP simplesmente 2. Assim, o MIPS para MFP = para MNFP =
4.20
Classe de instruo Freqncia no MFP Quant. no MFP (milhes) Quant. no MNFP (milhes)

1000 = 278 e o MIPS CPI

1000 = 500. CPI

Multiplicao de ponto flutuante Soma de ponto flutuante Diviso de ponto flutuante Instrues de inteiros Totais

10% 15% 5% 70% 100%

30 45 15 210 300

900 900 750 210 2760

MIPS 10 2760 tempo de execuo no MNFP = 5,52 segundos. 500 4.22 O CPI de cada mquina apenas a mdia ponderada dos CPIs para cada uma das classes de instruo. Assim:
6

4.21 Tempo de execuo =

Instrues

. Assim, o tempo de execuo

300 = 1,08 segundos, e o 278

CPI de Mbase CPI of Mopt

= 2(0,40) + 3(0,25) + 3 (0,25) + 5(0,10) = 0,8 + 0,75 + 0,75 + 0,50 = 2,8 ciclos/instruo = 2(0,40) + 2(0,25) + 3 (0,25) + 4(0,10) = 0,8 + 0,50 + 0,75 + 0,40 = 2,45 ciclos/instruo

Solues do Captulo 4

ELSEVIER

4.23 A classificao do MIPS em milhes de instrues por segundo. Assim, vemos que

Instrues por segundo = (Instrues/ciclos) * (Ciclos/segundo) = I/(CPI) * (Velocidade de clock) Assim: Classificao MIPS do Mbase = (500 106 ciclos/segundo) / (2,8 ciclos/instruo) = 178,6 106 instrues/segundo = 178,6 MIPS. e Classificao MIPS do Mopt = (600 106 ciclos/segundo) / (2,45 ciclos/instruo) = 244,9 106 instrues/segundo = 244,9 MIPS.
4.24 Como Mbase e Mopt utilizam o mesmo conjunto de instrues, o desempenho relativo pode ser determinado como a razo de suas classificaes MIPS (ao contrrio do tempo de execuo). Assim: Mopt mais rpido do que Mbase por um fator de (244,9 MIPS/178,9 MIPS) = 1,37. 4.25 Esse problema pode ser feito de uma dentre duas maneiras. Ou se encontra a nova combinao e se ajustam as freqncias primeiro, ou se encontra a nova contagem de instrues (relativa) e se divide o CPI por isso. Usamos a segunda.

Razo de instrues = 0,9 0,4 + 0,9 0,25 + 0,85 0,25 + 0,1 0,95 = 0,8925 Assim, podemos calcular o CPI como CPI = 2 0,4 0,9 3 0,25 + 0,9 3 + 0,25 0,85 + 5 01 , + 0,95 = 2,81 0,8925 IC CPI IC 2,8 = Velocidade de clock Velocidade de clock IC 0,8925 2,81 IC 2,5 = Velocidade de clock Velocidade de clock

4.26 O quanto Mcomp mais rpido do que Mbase?

Tempo de CPU Mbase =

Tempo de CPU Mcomp =

Portanto Velocidade de clock Desempenho Mcomp Tempo CPU Mbase 2,8 IC 2,8 = = = = 1,12 Velocidade de clock Desempenho Mbase Tempo CPU Mcomp 2,5 IC 2,5
4.27 O CPI diferente entre Mbase e Mboth; encontre este primeiro:

CPI Mboth =

2 0,4 0,9 + 2 0,25 0,9 + 3 0,25 0,85 + 4 01 , 0,95 = 2,45 0,8925

IC 2,8 2,8 Desempenho Mboth Tempo CPU Mbase Velocidade de clock 500 MHz = 1,53 = = = IC 0,8925 2,45 219 , Desempenho Mbase Tempo CPU Mboth Velocidade de clock 600 MHz

Solues do Captulo 4

4.28 Primeiro, calcule o crescimento de desempenho aps 6 e 8 meses. Aps 6 meses = 1,0346 =

1,22. Aps 8 meses = 1,0348 = 1,31. A melhor escolha seria implementar Mboth.
Meses Mbase Mcomp Mopt Mboth

0 ... 6 8

1,00

1,22 1,31

1,12 1,20

1,37 1,46 1,53

Solues do Captulo 5

Solues do Captulo 5
5.4 Buscar, ler registradores e escrever no registrador de destino levam um total de 300ps para

add/subtract e multiply/divide em ponto flutuante. Assim, add/subtract em ponto flutuante leva 300ps + 400ps = 700ps, e multiply/divide de ponto flutuante leva 300ps + 600ps = 900ps.
5.5 O caminho crtico de ciclo nico multiply/divide em ponto flutuante, de modo que o tempo de

ciclo 900ps.
5.6 A mdia ponderada dos tempos de ciclo para os diferentes tipos de instrues :

(600ps 0,3) + (550ps 0,15) + (400ps 0,25) + (350ps 0,10) + (200ps 0,05) + (700ps 0,05) + (900ps 0,10) = 532,5ps.
5.15 Se Regdst = 0, todas as instrues no formato-R no funcionaro corretamente, pois especificaremos o registrador errado para a escrita. Se OrigALU = 0, ento todas as instrues no formato-I, exceto o desvio, no funcionaro, pois no poderemos obter os 16 bits com sinal estendido na ALU. Se MemParaReg = 0, ento os loads no funcionaro. Se Zero = 0, a instruo de desvio nunca desviar, mesmo quando deveria. 5.16 Se Regdst = 1, os loads no funcionaro (destino incorreto). Se OrigALU = 1, ento todas as instrues no formato-R e todo os desvios no funcionaro corretamente, pois o segundo registrador lido no entrar na ALU. Se MemParaReg = 1, ento todas as instrues no formato-R no escrevero os dados corretos no banco de registradores. Se Zero = 1, todos os desvios sero tomados o tempo todo, mesmo que no devessem. 5.17 Se RegDst = 0, todas as instrues no formato-R sero incapazes de escrever no registrador apropriado (rd). Se MemParaReg = 0 ou IouD = 0, ento os loads no funcionaro. Se OrigALUA = 0, nenhuma das instrues funcionar corretamente, pois todas exigem que A seja operado pela ALU em algum ponto. 5.18 Se RegDst = 1, as instrues de load no funcionaro. Se MemParaReg = 1, todas as instrues no formato-R no funcionaro. Se IouD = 1, nenhuma instruo funcionar, pois o PC nunca ser usado para obter uma instruo. Se OrigALUA = 1, o contador de programa no ser corretamente incrementado por 4 e praticamente todas as instrues no funcionaro. 5.19 Nenhum acrscimo ao caminho de dados exigido. Uma nova linha dever ser acrescentada tabela verdade na Figura 5.18. O novo controle semelhante a load word, pois queremos usar a ALU para acrescentar o imediato a um registrador (e, assim, RegDst = 0, OrigALU = 1, OpALU = 00). O novo controle tambm semelhante a uma instruo no formato-R, pois queremos escrever o resultado da ALU em um registrador (e, assim, MemparaReg = 0, EscreveReg = 1) e, naturalmente, no estamos nos desviando ou usando memria (Branch = 0, LeMem = 0, EscreveMem = 0). 5.20 J temos um modo de mudar o PC baseado no endereo especificado (usando o caminho de dados para a instruo jump), mas precisaremos de um modo de colocar PC + 4 no registrador $ra (31), e isso exigir a mudana do caminho de dados. Podemos expandir o multiplexador controlado por RegDst para incluir 31 como nova entrada. Podemos expandir o multiplexador controlado por MemParaReg para ter PC + 4 como entrada. Como expandimos esses multiplexadores, as colunas inteiras para RegDst e MemParaReg precisam mudar corretamente na tabela verdade. A instruo jal no usa a ALU, de modo que OrigALU e OpALU podem ser dont cares. Teremos Jump = 1, EscreveReg = 1, e no estamos nos desviando ou usando memria (Branch = 0, LeMem = 0, EscreveMem = 0).

Solues do Captulo 5

ELSEVIER

5.21 Uma soluo possvel acrescentar um sinal de controle chamado ZeroInv, que seleciona se Zero ou Zero invertido uma entrada para a porta AND, usada para escolher qual dever ser o novo PC (assim, um novo multiplexador introduzido). O novo sinal de controle ZeroInv seria dont care sempre que o sinal de controle Branch for zero. Muitas outras solues so possveis. Nota para os instrutores: s vezes, solues diferentes submetidas pelos alunos realmente sero idnticas (por exemplo, um aluno desenha um multiplexador, o outro desenha portas, mas na verdade ambos implementaram isso da mesma maneira apenas em nveis de abstrao diferentes). Voc pode querer procurar solues que possa utilizar para enfatizar esse ponto para os seus alunos. Por exemplo, uma soluo alternativa seria usar Zero como uma entrada para um novo multiplexador que seleciona entre Branch e um novo sinal de controle Bnequal. Nesse caso, no haveria dont cares, porque, se no estivermos desviando, tanto Branch quanto Bnequal precisam ser zero. Alguns alunos podem apresentar essa mesma soluo com portas lgicas, em vez de muxes. 5.22 Nenhuma mudana necessria no caminho de dados. A nova variante exatamente como lw,

exceto que a ALU usar a entrada Dados da Leitura 2 em vez do imediato com sinal estendido. Naturalmente, o formato da instruo ter que mudar: o registrador de escrita ter que ser especificado pelo campo rd, em vez do campo rt. Porm, todos os caminhos necessrios j esto prontos devido s instrues com formato-R. Para modificar o controle, simplesmente temos que acrescentar uma nova linha tabela verdade existente. Para a nova instruo, RegDst = 1, OrigALU = 0, EscreveReg = 1, MemParaReg = 1, EsvreveMem = 0, OpALU = 00.
5.23 Nenhuma soluo fornecida. 5.24 Nenhuma soluo fornecida. 5.25 A chave reconhecer que no temos mais que passar pela ALU e depois para a memria. No gostaramos de somar zero usando a ALU; em vez disso, queremos fornecer um caminho diretamente da sada Dados da Leitura 1 do banco de registradores para as linhas de endereo read/write da memria (supondo que o formato da instruo no mude). A sada da ALU no seria mais conectada memria. O controle no precisa mudar, mas alguns dos sinais de controle agora so dont cares. 5.39 Nenhuma soluo fornecida. 5.40 O caminho de dados existente insuficiente. Conforme descrevemos na soluo do Exerccio

5.6, teremos que expandir os dois multiplexadores controlados por RegDst e MemParaReg. As etapas de execuo seriam Busca de instrues (inalterada) Decodificao de instrues e busca de registrador (inalterada)
jal: Reg[31] = PC; PC = PC [31-28] || (IR[25-0]<<2);

Observe que, neste caso, estamos escrevendo o PC aps ele j ter sido incrementado por 4 (na etapa de busca de instrues) no registrador $ra (assim, o caminho de dados exige que o PC seja uma entrada para o multiplexador MemParaReg e 31 precisa ser uma entrada para o multiplexador RegDst). Temos que modificar os estados existentes, para mostrar valores apropriados de RegDst, e MemParaReg e acrescentar um novo estado, que realize a instruo jal (e depois retorne ao estado 0) por meio de EscrevePC, OrigPC = 10, EscreveReg e valores apropriados para MemParaReg e RegDst.
5.41 Existem diversas opes de implementao. No estado 0, o PC incrementado de 4, de modo que temos que subtrair 4 do PC e colocar esse valor em um registrador. Isso exige dois novos estados (10 e 11). Haveria uma seta do estado 1 para o estado 10 rotulada com Op = wai, e deve haver setas incondicionais do estado 10 para o estado 11 e do estado 11 para o estado 0. O estado 10 realiza SadaALU = PC 4 (OrigALUA=0, OrigALUB=01 e OpALU=01), e o estado 11 realiza Reg[IR[20-16]]=SadaALU (RegDst=0, MemParaReg=0, EscreveReg). Uma soluo alternativa conta com a idia de que wai poderia ser tratada como uma instruo de desvio. Se um 1 ocupasse o campo de valor imediato

Solues do Captulo 5

de 16 bits de uma instruo wai, ento o clculo do endereo de destino do desvio realmente calcula o PC da prpria instruo wai. Essa soluo inteligente reduz em um a quantidade de novos estados de controle necessrios.
5.42 A instruo jump memory se comporta como uma load word at que a memria seja lida. Os

dados saindo da memria precisam ser depositados no PC. Isso exigir uma nova entrada no multiplexador, controlado por OrigPC. Acrescentamos um novo estado saindo do estado 3, que verifica Op = jump memory (e modificamos a transio para o estado 4 para garantir Op = lw). O novo estado tem EscrevePC, OrigPC = 11. As transies para os estados 2 e 3 precisam incluir tambm Op = jump memory.
5.43 A instruo exigir o uso da ALU duas vezes. Um multiplexador dever ser acrescentado para permitir que a ALU use o resultado anterior, produzido pela ALU (armazenado em SadaALU), como uma entrada para a segunda adio. Observe que as mudanas tambm sero necessrias para a leitura do registrador. A instruo pode ser implementada em 5 ciclos, lendo a origem do terceiro registrador durante o ciclo em que a primeira adio est ocorrendo. Claramente, um multiplexador e um novo sinal de controle sero necessrios para a entrada de uma das portas de leitura de registrador. 5.44 O campo rt da instruo jump register contm 0. Assim, junto com rs, lemos $0. Para levar o rs sada da ALU, podemos realizar uma adio fictcia de rs + $0. J temos um caminho de SadaALU para o PC. Podemos usar esse caminho para carregar o PC com rs. A mquina de estados finitos precisar de um novo estado para quando o opcode for 000000 e o cdigo da funo for 001000. A condio atual para entrar no estado 6 precisa ser modificada para garantir que o cdigo da funo no seja 001000. No novo estado, queremos a combinao apropriada dos estados 0 e 6: OrigALUA = 1, OrigALUB = 00, EscrevePC, OrigPC = 00, e naturalmente nos certificamos que uma adio seja realizada com OpALU = 00. 5.45 O mix de instrues :

Classe de instruo

Freqncia

Loads Stores Tipo-R Jump/branch

26% 10% 49% 15%

Os CPIs para cada mquina, por classe de instruo, so:

Classe de instruo CPIs M1 CPIs M2 CPIs M3

Loads Stores Tipo-R Jump/branch CPI efetivo

5 4 4 3 4,11

4 4 3 3 3,36

3 3 3 3 3

MIPSM1 = MIPSM2 =

500 = 121,7 411 , 400 = 119,0 3,36

Solues do Captulo 5

ELSEVIER

MIPSM3 =

250 = 83,3 3,0

Assim, a mquina M1 original a mais rpida para esse mix. M3 seria a mais rpida para um mix de instrues que tivesse apenas loads.
5.46 Aqui est uma seqncia de cdigo possvel: beq move: lw sw addi addi addi bne done: ... $t3, $t4, $t4, $t1, $t2, $t3, $t3, $zero, done 0($t1) 0($t2) $t1, 4 $t2, 4 $t3, 1 $zero, move

O nmero de ciclos exigidos determinado pelo clculo do nmero de instrues exigidas. Para copiar 100 words, realizaremos 100 loads, 100 stores, 300 adds e 101 desvios. Depois, usamos o nmero de ciclos para cada instruo para chegar a 500 ciclos para os loads, 400 ciclos para os stores, 1.200 ciclos para os adds e 303 ciclos para os desvios. O total geral de 2.403 ciclos.
5.50 Nenhuma soluo fornecida. 5.53 Nenhuma soluo fornecida. 5.54 Precisamos alterar Dispatch 1 e Dispatch 2 e introduzir uma nova entrada (talvez inserida aps SW2) com um rtulo ADDI2 e um controle de registrador de Write ALU rt, que semelhante a Write ALU, exceto porque utiliza o campo rt em vez de rd. Voc poderia argumentar que outras mudanas devero ser feitas nos rtulos existentes para tornar as coisas mais fceis de entender. 5.55 Nenhuma soluo fornecida.

Solues do Captulo 6

Solues do Captulo 6
6.7 Obviamente, ou o load ou o addi precisam ocupar o slot do delayed branch. No podemos simplesmente colocar o addi no slot, pois a instruo de desvio precisa comparar $3 com o registrador $4 e a instruo addi muda $3. Para mover o load para o slot do delayed branch, temos que observar que $3 ter mudado. Se quiser, voc poder pensar nisso como uma transformao de duas etapas. Pri-

meiro, reescrevemos o cdigo da seguinte maneira:

Loop: addi $3, $3, 4 lw $2, 96($3) beq $3, $4, Loop

Depois, podemos mover o load para o slot do delayed branch:

Loop: addi $3, $3, 4 beq $3, $4, Loop lw $2, 96($3) 6.7 Veja a figura a seguir:
Tempo (em ciclos de clock) Ordem CC 1 CC 2 de execuo do programa (em instrues) add $4, $2, $3 IM Reg

# slot de desvio adiado

CC 3

CC 4

CC 5

CC 6

ALU

DM

Reg

sw $5, 4($2)

IM

Reg

ALU

DM

Reg

6.8 Veja a figura a seguir:

Tempo (em ciclos de clock) Ordem de execuo do programa CC 1 CC 2 (em instrues) add $4, $2, $3 sw $5, 4($2) Busca de instrues Decodificao de instrues Busca de instrues

CC 3 Execuo Decodificao de instrues

CC 4 Acesso aos dados Execuo

CC 5 Escrita do Resultado Acesso aos dados

CC 6

Escrita do Resultado

Solues do Captulo 6

ELSEVIER

6.9 Veja as figuras a seguir.

add $4, $2, $3 Busca de instrues
0

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Registrador Dados da para Escrita Leitura 2 Dados para Escrita 16 Extenso 32 de sinal

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados Dados para Escrita

Dados da Leitura

M u x
0

Clock 1

sw $5, 4($2) Busca de instrues

0

add $4, $2, $3 Decodificao de instrues

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Dados da Registrador Leitura 2 para Escrita Dados para Escrita 16 Extenso de sinal 32

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados Dados para Escrita

Dados da Leitura

M u x
0

Clock 2

Solues do Captulo 6

sw $5, 4($2) Decodificao de instrues

0

add $4, $2, $3 Execuo

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Dados da Registrador Leitura 2 para Escrita Dados para Escrita 16 Extenso de sinal 32

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados Dados para Escrita

Dados da Leitura

M u x
0

Clock 3

sw $5, 4($2) Execuo

0

add $4, $2, $3 Memria

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Dados da Registrador Leitura 2 para Escrita Dados para Escrita 16 Extenso de sinal 32

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados Dados para Escrita

Dados da Leitura

M u x
0

Clock 4

Solues do Captulo 6

ELSEVIER

sw $5, 4($2) Memria

0

add $4, $2, $3 Escrita do Resultado

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Dados da Registrador Leitura 2 para Escrita Dados para Escrita 16 Extenso de sinal 32

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados

Dados da Leitura

M u x
0

Clock 5

sw $5, 4($2) Escrita do Resultado

0

M u x
1

IF/ID Add 4 Registrador de Leitura 1 Registrador Dados da de Leitura 2 Leitura 1 Registradores Dados da Registrador Leitura 2 para Escrita Dados para Escrita 16 Extenso de sinal 32

ID/EX

EX/MEM

MEM/WB

ADD Desloc. 2 esq.

Resultado do Somador

PC

Endereo Memria de instrues

Instruo

M u x
1

Zero ALU Resultado da ALU

Endereo

Memria de dados Dados para Escrita

Dados da Leitura

M u x
0

Clock 6

Solues do Captulo 6

6.10 Considere cada registrador:

n n n n

IF/ID contm PC + 4 (32 bits) e a instruo (32 bits), para um total de 64 bits. ID/EX contm PC + 4 (32 bits), Dados da Leitura 1 e 2 (32 bits cada), os dados com extenso de sinal (32 bits) e dois destinos possveis (5 bits cada), para um total de 138 bits. EX/MEM contm o destino do PC se desvio (32 bits), Zero (1 bit), Resultado da ALU (32 bits), Dados da Leitura 2 (32 bits) e um registrador de destino (5 bits), com um total de 102 bits. MEM/WB contm os dados saindo da memria (32 bits), Resultado da ALU (32 bits) e o registrador de destino (5 bits), com um total de 69 bits.

6.11 Nenhuma soluo fornecida. 6.15 Nenhuma soluo fornecida. 6.16 Veja as figuras a seguir.
and $5, $4, $1 add $4, $2, $1 add $1, $1, $3
ID/EX 10 WB M EX 2 $2 $1 M u x Registradores ALU $1 $3 M u x 2 1 4 1 3 1 M u x Unidade de encaminhamento Memria de dados M u x 10 EX/ME M WB M MEM/WB WB

antes<1>

antes<2>

Controle IF/ID

Instruo

PC

Memria de instrues

Clock 3 aps<1> and $5, $4, $1 add $4, $2, $1

ID/E X 10 WB M EX 4 $4 $2 M u x Registradores ALU $1 $1 M u x 4 1 5 2 1 4 M u x Unidade de encaminhamento 1 Memria de dados M u x 10 EX/MEM WB M 10 MEM/WB WB

add $1, . . .

antes<1>

Controle IF/ID

PC

Memria de instrues

Clock 4

Instruo

Solues do Captulo 6

ELSEVIER

aps<2>

aps<1>

add $5, $4, $1

ID/E X WB Controle M EX $4 10

add $4, . . .

add $1, . . .

EX/MEM WB M 10 MEM/WB WB 1

IF/ID

Instruo

M u x 1 Registradores ALU $1 M u x 4 1 5 M u x Unidade de encaminhamento 4 1 Memria de dados M u x

PC

Memria de instrues

Clock 5

6.20 Esta soluo verifica a combinao lw-sw quando o lw est no estgio MEM e o sw est no es-

tgio EX.
EX/MEM MEM/WB

ALUSrc M u x

ALU Memria de dados M u x

M u x

Unidade de encaminhamento

if

(ID/EX.EscreveMem and // sw no estgio EX? EX/MEM.LeMem and // lw no estgio MEM? (ID/EX.RegisterRt = EX/MEM.RegisterRd) and // mesmo registrador? (EX/MEM.RegisterRd 0)) // mas no r0? Mux = 1 // encaminha valor lw // no encaminha

then else Mux = 0

Solues do Captulo 6

A soluo a seguir verifica a combinao lw-sw quando o lw est no estgio WB e o sw est no estgio MEM.
if (EX/MEM.EsvreveMem and // sw no estgio MEM? (MEM/WB.MemParaReg = 1) and MEM/WB.EscreveReg and // lw no estgio WB? (EX/MEM.RegisterRd = MEM/WB.RegisterRd) and // mesmo registrador? (MEM/WB.RegisterRd ? 0)) // mas no r0? Mux = 1 // encaminha valor de lw else Mux = 0 // no encaminha

then

Para que essa soluo funcione, temos que fazer uma pequena modificao no hardware: temos que poder verificar se o registrador de origem de sw (rt) o mesmo que o registrador de destino de lw (como na soluo anterior). Porm, o registrador de origem sw no est necessariamente disponvel no estgio MEM. Isso facilmente resolvido: como se encontra agora, o valor de RegDst para sw X, ou dont care (consulte a Figura 6.25, na pgina 302). Lembre-se de que RegDst escolhe se rt ou rd o registrador de destino de uma instruo. Como esse valor nunca usado por um sw, podemos fazer o que quisermos com ele portanto, sempre vamos escolher rt. Isso garante que o registrador de origem de um sw esteja disponvel para a equao acima, no estgio MEM (rt estar em EX/MEM.WriteRegister). Um stall lw-sw pode ser evitado se o registrador de deslocamento de sw (rs) no for o registrador de destino de lw, ou se o registrador de destino de lw for r0.
if ID/EX.LeMem and // lw no estgio EX? ((ID/EX.RegisterRt = IF/ID.RegisterRs) or // mesmo registrador? (ID/EX.RegisterRt = IF/ID.RegisterRt)) and // mas no... not (IF/ID.EscreveMem and // sw no estgio ID? (ID/EX.RegisterRt = IF/ID.RegisterRs)) and // mesmo registrador? (ID/EX.RegisterRt 0) // registrador r0? Atrasa o pipeline

then

Observe que IF/ID.EscreveMem um novo sinal, significando uma instruo store. Esta precisa ser decodificada a partir do opcode. A verificao de que o destino de lw no r0, no feita na frmula de stall da pgina 413. Isso est correto. O compilador pode ser projetado para nunca gerar cdigo para carregar o registrador r0, ou um stall desnecessrio pode ser aceito, ou a verificao pode ser acrescentada, como feito aqui.

Solues do Captulo 6

ELSEVIER

6.24 Veja as figuras a seguir.

sub $4, $4, $2 add $4, $5, $2
2 5 Unidade de deteco de hazard

1w $2, 20($1)
ID/EX.MemRead ID/EX 00 WB M EX 11

antes<1>

antes<2>

IF/IDWrite

EX/MEM WB M $1
M u x

Controle 0

M u x

MEM/WB WB

IF/ID

PCWrite

$5

Instruo

2 Registradores $2 $2

PC

Memria de instrues

ALU
M u x

Memria de dados

M u x

5 2 4 ID/EX.RegisterR t

2 2 2

M u x

Unidade de encaminhamento

Clock 3

sub $4, $4, $2

add $4, $5, $2

2 5 Unidade de deteco de hazard ID/EX.MemRead

bolha
ID/EX 10
M u x

1w $2, 20($1)

antes<1>

IF/IDWrite

WB M EX

00 EX/MEM WB M $5
M u x

Controle 0

11

MEM/WB WB

IF/ID

PCWrite

$5

Instruo

2 Registradores

PC

Memria de instrues

ALU $2 $2
M u x

Memria de dados

M u x

5 2 PC ID/EX.RegisterRt 4

5 2 4
M u x

2 Unidade de encaminhamento

Clock 4

Solues do Captulo 6

aps<1>

add $4, $4, $2

4 2 Unidade de deteco de hazard ID/EX.MemRead ID/EX 10
M u x

add $4, $5, $2

bolha

1w $2, 20($1)

IF/IDWrite

WB M EX

10 EX/MEM WB M $5
M u x

Controle 0

MEM/WB WB 11

IF/ID

PCWrite

$5

Instruo

2 Registradores

PC

Memria de instrues

ALU $2 $2
M u x

Memria de dados

M u x

4 2 PC ID/EX.RegisterRt 4

5 2 4
M u x

2 Unidade de encaminhamento

Clock 5

aps<2>

aps<1>
Unidade de deteco de hazard ID/EX.MemRead

sub $4, $4, $2

ID/EX WB Controle 0
M u x

and $4, $5, $2

bolha

IF/IDWrite

10 EX/MEM WB M $5 10 MEM/WB WB 0

M EX

IF/ID

PCWrite

Instruo

M u x

PC

Memria de instrues

Registradores ALU $2
M u x

Memria de dados

M u x

4 2 4
M u x

4 Unidade de encaminhamento

Clock 6

10

Solues do Captulo 6

ELSEVIER

6.25 Nenhuma soluo fornecida. 6.26 O endereo de memria agora pode vir direto de Dados da Leitura 1, em vez da sada da ALU; isso significa que o acesso memria pode ser feito no estgio EX, pois no precisa esperar pela ALU. Assim, o estgio MEM pode ser completamente eliminado. (A deciso de desvio pode ser cuidada em outro estgio.) O nmero de instrues aumentar porque algumas instrues de adio explcitas sero necessrias para substituir as somas que costumavam ser implcitas nos loads e stores com deslocamentos diferentes de zero. O CPI diminuir porque os stalls no sero mais necessrios quando um load for seguido imediatamente por uma instruo que usa o valor carregado. O encaminhamento no resolver esse hazard, assim como para os resultados da ALU usados na instruo seguinte. 6.27 Uma instruo addm precisa de seis etapas:

1. Buscar a instruo. 2. Decodificar a instruo e os registradores de leitura. 3. Calcular o endereo de memria do operando na memria. 4. Ler a memria. 5. Realizar a adio. 6. Escrever no registrador.
6.28 Nenhuma soluo fornecida. 6.31 slt $1, $8, $9 movz $10, $8, $1 movn $10, $9, $1 6.32 O motivo pelo qual as seqncias desse tipo podem ter desempenho mais alto do que as ver-

ses que usam desvio condicional, mesmo que a contagem de instrues no seja reduzida, que no introduzido um hazard de controle, diferente do que ocorre com o desvio. O desvio geralmente introduz stalls, que desperdiam ciclos, pois o fluxo de execuo seqencial normal interrompido. As novas instrues, ao contrrio, fazem parte do fluxo de execuo seqencial normal. Os nicos hazards que eles introduzem so hazards de dados normais, como em qualquer instruo da ALU, e aqueles que podem ser completamente resolvidos usando o encaminhamento.

Solues do Captulo 7

Solues do Captulo 7
7.6 7.8 Os principais recursos das solues para esses problemas:
n n n n

Baixa localidade temporal para o cdigo significa nenhum loop e nenhuma reutilizao de instrues. Alta localidade temporal para o cdigo significa loops pequenos com muita reutilizao. Baixa localidade espacial para o cdigo significa muitos jumps para locais distantes. Alta localidade espacial para o cdigo significa nenhum desvio/jump.

7.15 CPI efetivo = CPI base + Taxa de falhas por instruo Penalidade de falha. Para configuraes de memria (a), (b) e (c):

a. CPI efetivo = 1,2 + 0,005 177 = 2,085 clocks/instruo. b. CPI efetivo = 1,2 + 0,005 45 = 1,425 clocks/instruo. c. CPI efetivo = 1,2 + 0,005 57 = 1,485 clocks/instruo. Agora Aumento de velocidade de A sobre B = Tempo de execuo B/Tempo de execuo A e Tempo de execuo = Nmero de instrues CPI Tempo de ciclo de clock Temos a mesma CPU executando o mesmo software nas diversas configuraes de memria, de modo que o nmero de instrues e o tempo de ciclo de clock so fixos. Assim, a velocidade pode ser comparada comparando-se o CPI. Aumento de velocidade da configurao (b) sobre a configurao (a) = 2,085/1,425 = 1,46 Aumento de velocidade da configurao (b) sobre a configurao (c) = 1,485/1,425 = 1,04
7.20 A maior cache de instrues diretamente mapeada que voc pode construir com blocos de duas words teria um tamanho de 512KB. O desmembramento de endereos de 13 bits para tag, 16 bits para ndice, 1 bit para deslocamento de bloco e 2 bits para deslocamento de byte. As SRAMs sero usadas de modo que oito delas formem o array de dados (2 4) e duas delas formem o array de tags (2 1). 7.21 A maior cache de instrues diretamente mapeada que voc pode construir com blocos de quatro words teria um tamanho de 1024KB. O desmembramento de endereos de 12 bits para tag, 16 bits para ndice, 2 bits para deslocamento de bloco e 2 bits para deslocamento de byte. As SRAMs sero usadas de modo que 16 delas formem o array de dados (2 8) e 2 delas formem o array de tags (2 1).

Solues do Captulo 7

ELSEVIER

7.22
Referncia Acerto ou Falha

2 3 11 16 21 13 64 48 19 11 3 22 4 27 6 11

Falha Falha Falha Falha Falha Falha Falha Falha Falha Acerto Falha Falha Falha Falha Falha Falha

Aqui est o estado final da cache com blocos dados na ordem LRU:
Conjunto # Endereo do bloco 0 (mais recente) Endereo do bloco 1 (mais recente)

0 1 2 3 4 5 6 7

48

64

2 11 4 13 6 21 22 27

7.23
Referncia Acerto ou Falha

2 3 11 16 21 13 64 48 19 11 3 22 4 27 6 11

Falha Falha Falha Falha Falha Falha Falha Falha Falha Acerto Acerto Falha Falha Falha Falha Acerto

Solues do Captulo 7

Aqui est o estado final da cache:

Nmero bloco Endereo Ordem LRU

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

11 6 27 4 22 3 19 48 64 13 21 16 2

Usado mais recentemente

Usado menos recentemente

7.24
Referncia Acerto ou Falha

2 3 11 16 21 13 64 48 19 11 3 22 4 27 6 11

Falha Acerto Falha Falha Falha Falha Falha Falha Falha Falha Falha Falha Falha Falha Acerto Falha

Aqui est o estado final da cache com blocos dados na ordem LRU:
Bloco Endereo Ordem LRU

0 1 2 3

[8, 9, 10, 11] [4, 5, 6, 7] [24, 25, 26, 27] [20, 21, 22, 23]

(mais recente)

(menos recente)

Solues do Captulo 7

ELSEVIER

7.27 Cache totalmente associativa de 3K words de dados? Sim. Uma cache totalmente associativa tem apenas um conjunto, de modo que nenhum ndice usado para acessar a cache. Em vez disso, temos que comparar a tag com cada local de cache (3K deles). Cache associativa por conjuntos de 3K words? Sim. Implemente uma cache associativa por conjuntos de trs vias. Isso significa que haver 1.024 conjuntos, o que exige um campo de ndice de 10 bits para acessar. Cache mapeada diretamente com 3K words? No. (No pode ser feito com eficincia.) Para acessar uma cache mapeada diretamente com 3K words, preciso entre 11 e 12 bits de ndice. O uso de 11 bits nos permitir acessar apenas 2K words da cache, enquanto o uso de 12 bits nos far mapear alguns endereos para locais de cache no existentes. 7.28 Cache totalmente associativa de 300 words de dados? Sim. Uma cache totalmente associativa tem apenas um conjunto, de modo que nenhum ndice usado para acessar a cache. Em vez disso, temos que comparar a tag com cada local de cache (300 deles). Cache associativa por conjuntos de 300 words? Sim. Implemente uma cache associativa por conjuntos de 75 vias. Isso significa que haver 4 conjuntos, o que exige um campo de ndice de 2 bits para acessar. Cache mapeada diretamente com 300 words? No. (No pode ser feito com eficincia.) Para acessar uma cache mapeada diretamente com 300 words, preciso entre 8 e 9 bits de ndice. O uso de 8 bits nos permitir acessar apenas 256 words da cache, enquanto o uso de 9 bits nos far mapear alguns endereos para locais de cache no existentes. 7.33 Podemos montar uma cache de 384 KB. O desmembramento de endereos de 14 bits para tag, 16 bits para ndice de conjunto, 0 bits para deslocamento de bloco e 2 bits para deslocamento de byte. Ser necessrio um total de 18 chips; 6 para o overhead. 7.34 Nenhuma soluo fornecida. 7.40 Usando um endereamento virtual de 32 bits e um tamanho de pgina de 4KB, o endereo virtual particionado em um nmero de pgina virtual de 20 bits e um deslocamento de pgina de 12 bits. Dividimos o nmero de pgina virtual em dois campos de 10 bits. O primeiro campo o nmero da tabela de pginas e usado como um ndice para a tabela de pginas de primeiro nvel. O tamanho da tabela de pginas de primeiro nvel 210 entradas 4 bytes/entrada = 212 bytes = uma pgina. 7.41 As pginas possuem um tamanho de 4KB e cada entrada utiliza 32 bits, de modo que obtemos 1K de entradas da tabela de pginas em uma pgina. Cada uma dessas entradas aponta para uma pgina fsica de 4KB, possibilitando enderear 210 212 = 222 bytes = 4MB de memria. Mas somente metade destes endereos vlida, de modo que 2MB do nosso espao de endereamento virtual estaria na memria fsica. Se houver 1K de entradas por tabela de pginas, o deslocamento da tabela de pginas ocupar 10 bits e o nmero da tabela de pginas tambm ocupar 10 bits. Assim, s precisamos de 4 KB para armazenar tambm a tabela de pginas de primeiro nvel.

Solues do Captulo 8

Solues do Captulo 8
8.25 Nenhuma soluo fornecida. 8.32 Para saturar um barramento de E/S, precisamos ter duas transferncias simultneas de 2 dis-

cos (teoricamente). Isso significa que 2 = 2,5 (T /(8,1 + T)), onde T o tempo de transferncia. Assim, T = 32,4 ms. Isso corresponde a 1.296KB leituras, de modo que os blocos precisam ser de 2MB. Um disco transferindo constantemente pode realizar 40MB/2MB = 20 transferncias a cada segundo. Com esse tamanho de bloco, podemos realizar 2 transferncias por barramento de E/S, para um total de 50 transferncias por barramento por segundo. Temos dois barramentos, de modo que podemos realizar 100 transferncias por segundo. Essa uma largura de banda de 2MB 100 = 200MB/seg.
8.33 Quantos ciclos para ler ou escrever 8 words? Usando o exemplo atual (barramento de 64 bits

com barramento de memria de 128 bits, 1 + 40 + 2 (2+2) = 49 ciclos. A penalidade da falha mdia de 0,4 49 + 49 = 68,6 ciclos. Os ciclos de falha por instruo = 68,6 0,05 = 3,43. Se aumentarmos o tamanho do bloco para 16, obtemos 57 ciclos para 16 words, o que cria 79,8 0,03 = 2,39 ciclos de falha por instruo.
8.37 Nenhuma soluo fornecida. 8.38 Nenhuma soluo fornecida. 8.39 Nenhuma soluo fornecida.

Solues do Apndice B

Solues do Apndice B
B.1 Isso mostrado facilmente pela induo.

Caso base: uma tabela verdade com uma entrada possui claramente duas linhas (21). Considere que uma tabela verdade com n entradas possui 2n linhas. Uma tabela verdade com n + 1 linhas possui 2n linhas, onde a entrada n + 1 0 e 2n linhas onde a entrada n + 1 1, gerando um total de 2n+1 linhas.
B.2 Nenhuma soluo fornecida. B.3

Funo NOT: 0 + A = A, assim

A 0

Funo OR: A + B = A + B, assim

A B A+B 0

Funo OR: A B = A + B = A + B, assim

A 0 0 B A B

B.4 Funo NOT: 1 A = A, assim

A 1

Funo AND: A B = A B, assim

A B A B 1

Funo OR: A B = A + B = A + B, assim

A 1 B 1 A+B

Solues do Apndice B

ELSEVIER

B.13
Entradas A B S Sada C

0 1 X X

X X 0 1

0 0 1 1

0 1 0 1

B.29 No haver diferenas, desde que D nunca mude quando C estiver ativo (com relao ao latch D). B.30 A chave que so necessrios dois multiplexadores e quatro flip-flops D. B.31 O detalhe aqui que existem dois estados com a mesma sada (a luz do meio acesa), pois a luz

seguinte a da esquerda ou a da direita. Esse exemplo demonstra que as sadas e os estados so diferentes.
B.32 Nenhuma soluo fornecida. B.33 A idia bsica criar um nico bit que troque primeiro. Depois, crie o contador colocando es-

ses contadores de 1 bit em cascata, usando a sada de cada estgio para causar a troca do seguinte; consideramos que inc e reset no esto ativos ao mesmo tempo. Esse circuito assume flip-flops D acionados por transio de descida.
reset inc reset reset

C 0 0 1 M u x 0 D Q 0 1 M u x D

C 0 Q 0 1 M u x D

C Q

Bit 0

Bit 1

Bit 2

B.34 Nenhuma soluo fornecida.

Solues do Apndice B

B.35 Consideramos que a luz muda somente se um carro tiver chegado da direo oposta e o temporizador de 30 segundos tiver expirado. Aqui est a mquina de estados finitos. Fizemos uma pequena simplificao e, na realidade, criamos o ciclo de luz em incrementos de 34 segundos. Isso poderia ser melhorado detectando um carro e a expirao do temporizador ao mesmo tempo, mas isso ainda significa que, quando um carro chega, pode-se levar at quatro segundos antes que a luz amarela seja sinalizada.
TimerSignal NSgreen TimerReset EWgreen TimerReset

TimerSignal

Timersignal

Timersignal

EWcar

NScar

EWcar

NScar

NSyellow

EWyellow

B.36 Nenhuma soluo fornecida. B.37 Nenhuma soluo fornecida. B.38 Nenhuma soluo fornecida.