Universidade Metodista de Angola

Faculdade de Engenharia e Arquitetura

Curso de Engenharia Informática

Relatório:
RESOLUÇÃO DE EXERCÍCIOS REFERENTES AO MODELO DE
ARQUITERURA MIPS

Luanda - 2023
 Universidade Metodista de Angola
Faculdade de Engenharia e Arquitetura
Curso de Engenharia Informática

Relatório:
RESOLUÇÃO DE EXERCÍCIOS REFERENTES AO MODELO DE
ARQUITETURA MIPS

Integrantes do grupo:
46753 – Eurídice Gomes Simão
46668 – Eliane Helena Gaspar

_______________________
Profª. Aimé Delacruz

Luanda - 2023
 Índice
Enunciado do exercício ............................................................................................................................. 1

Considerações ........................................................................................................................................... 1

Exercício 1 ................................................................................................................................................ 2

Resolução da alíena: a) Identifique todas as dependências de dados existentes neste programa ......... 2

Resolução da alínea: b) Introduza instruções nop necessárias para que a execução do programa
esteja correta ......................................................................................................................................... 3

Resolução da alínea: c) Calcule o CPI mínimo e o CPI efetivo na execução deste programa neste
processador............................................................................................................................................ 4

Calculando o CPI mínimo ................................................................................................................. 4

Calculando o CPI efetivo .................................................................................................................. 5

Comentário ............................................................................................................................................ 6

Exercício 2 ................................................................................................................................................ 7

Tempo de execução ............................................................................................................................... 8

Enunciado do exercício
Considere o modelo de uma arquitetura MIPS com o pipeline da instrução abaixo, sem unidade
de encaminhamento de dados (foward unit), sem unidade de detenção de anomalias (hazard detection
unit), com a escrita dos valores em registos (write back) na primeira metade do ciclo, com empates
(stall) do pipeline em instruções de salto e com "quente" e de dimensão infinita. Considere a seguinte
instrução Assembly MIPS:
1. mov $s1, $0
2. mov $s2, $0
3. mov $s0, -1024
4. soma:
5. lw $t0, 0xC400($s0)
6. addu $s1, $s1, $t0
7. sw $s1, 0xE400($s0)
8. addu $s2, $s2, $s1
9. addiu $s0, $s0, +4
10. bne $s0, $0, soma
11. mov $s1, $0

Considerações
O código apresentado é um exemplo de um loop que soma os valores armazenados em uma
região da memória em um registrador. A seguir, será feita uma análise do funcionamento desse código
no pipeline MIPS descrito.

1
Exercício 1
Identifique todas as depêndencias de dados existentes neste programa e introduza instruções nop
(no operation) necessárias para que a execução do programa esteja correcta. Calcule o CPI mínimo
e o CPI efetivo na execução do deste programa neste processador. Comente o resultado.
Resolução:
Podemos desmembrar o exercício nas seguintes alíenas:
a) Identifique todas as dependências de dados existentes neste programa;
b) Introduza instruções nop necessárias para que a execução do programa esteja correcta;
c) Calcule o CPI mínimo e o CPI efetivo na execução deste programa neste processador.

Podemos resolver o exercício por etapas, desta forma, simplificando o entendimento do leitor durante
a resolução do exercício.
Resolução da alíena: a) Identifique todas as dependências de dados existentes neste programa
Existem depêndencias de dados no seguinte conjunto de intruções:
5. lw $t0, 0xC400($s0)
6. addu $s1, $s1, $t0
7. sw $s1, 0xE400($s0)
8. addu $s2, $s2, $s1
Explicação do conjunto de dados:
 A instrução addu $s1, $s2, $t0 depende do resultado da instrução anterior lw $t0,
0xC400($s0), pois usa o valor carregado em $t0.
 A instrução sw $s1, 0xE400($s0) depende do resultado da instrução anterior addu $s1, $s1,
$t0, pois usa o valor armazenado em $s1.
 A instrução addu $s2, $s2, $s1 depende do resultado da instrução anterior sw $s1,
0xE400($s0), pois usa o valor armazenado em $s1.

2
Resolução da alínea: b) Introduza instruções nop necessárias para que a execução do
programa esteja correta
Para resolver as dependências de dados, são necessárias instruções nop (do inglês No
OPeration) que atrasam (ou empatam, ou seja, criam estágios de empate também conhecidos como
stall ou bolhas) a execução do pipeline, para permitir que os valores sejam buscados e atualizados
corretamente, evitando assim os hazards:
1. mov $s1, $0
2. mov $s2, $0
3. mov $s0, -1024
4. soma:
5. lw $t0, 0xC400($s0)
6. nop
7. nop
8. addu $s1, $s1, $t0
9. nop
10. sw $s1, 0xE400($s0)
11. nop
12. nop
13. addu $s2, $s2, $s1
14. addiu $s0, $s0, +4
15. bne $s0, $0, soma
16. nop
17. mov $s1, $0

Observação: Com a inserção das instruções NOP, podemos garantir que cada instrução só será
executada quando todos os seus operandos estiverem disponíveis e que não haverá hazard de
controle causado pelas instruções de salto. Vale ressaltar que, com a inserção de instruções NOP, o
desempenho do programa pode ser afetado, já que o pipeline estará sendo preenchido com
instruções que não realizam nenhuma operação.

3
Resolução da alínea: c) Calcule o CPI mínimo e o CPI efetivo na execução deste programa
neste processador
Para calcular os CPI’s (ciclos por instrução) mínimo e efetivo, precisamos analisar as
instruções presentes no código e as possíveis dependências entre elas. O CPI mínimo é calculado
considerando que não há conflitos de dados ou desvios condicionais. Já o CPI efetivo é afetado
por possíveis conflitos de dados e desvios condicionais.
Calculando o CPI mínimo
Para calcular o CPI mínimo da instrução assembly dada, é necessário considerar apenas o ciclo
mais longo entre todas as intruções, independentemente do número de ciclos que as outras intruções
possam ter. Com base no pipeline fornecido e assumindo que não há hazards e que o pipeline
sempre está cheio, o número de ciclos de clock necessários para cada instrução é apresentado na
seguinte tabela:
Instrução Números de ciclos para a sua execução
mov $s1, $0 1
mov $s2, $0 1
mov $s0, -1024 1
lw $t0 0xC400($s0) 5
addu $s1, $s1, $t0 3
sw $s1, 0xE400($s0) 4
addu $s2, $s2, $s1 3
addiu $s0, $0, +4 3
bne $s0, $0, soma 3
mov $s1, $0 1
Tabela 1 - Representação do ciclos de clock necessários para cada instrução (CPI mínimo)

Como podemos ver, a intrução com o número de ciclos mais longo é instrução lw, então
temos:
 CPI mínimo 5 / 10
 CPI mínimo = 0.5
Portanto, o CPI mínimo para a sequência de instruções dada, de acordo com a pipeline
especificada, é de 0.5 ciclos de clock por instrução.

4
Calculando o CPI efetivo
Para calcular o CPI efetivo temos que contar o número de ciclos de clock para executar cada
instrução, levando em consideração os possíveis atrasos e espera de dados, o número de ciclos de
clock necessários para cada instrução é apresentado na seguinte tabela:
Instrução Números de ciclos para a sua execução
mov $s1, $0 1
mov $s2, $0 1
mov $s0, -1024 1
lw $t0 0xC400($s0) 6
nop 1
nop 1
addu $s1, $s1, $t0 4
nop 1
sw $s1, 0xE400($s0) 5
nop 1
addu $s2, $s2, $s1 4
addiu $s0, $0, +4 4
bne $s0, $0, soma 3
nop 1
mov $s1, $0 1
Tabela 2 - Representação do ciclos de clock necessários para cada instrução (CPI efetivo)

Somando o número de ciclos de clock para cada instrução e dividindo pelo número total de
instruções, temos:
 CPI efetivo = (1 + 1 + 1 + 6 + 1 + 1 + 4 + 1 + 5 + 1 + 4 + 4 + 3 + 1 + 1) / 15
 CPI efetivo = 36 / 15
 CPI efetivo = 2.26.
Portanto, o CPI efetivo para a sequência de instruções dada, de acordo com a pipeline
especificada, é de 2.26 ciclos de clock por instrução.

5
Comentário
O resultado de um CPI mínimo indica que, em um cenário ideal sem atrasos adicionais, cada
instrução seria executada em média 1 ciclo e, portanto, o processador seria capaz de executar uma
instrução em pelo menos 1 ciclo. No entanto, no mundo real, há uma série de atrasos e limitações que
afetam o desempenho do processador, incluindo dependências de dados, saltos, escritas em
registradores, entre outros.
O CPI efetivo de 2.26 indica que, na prática, o processador leva em média mais do que um
ciclo para executar cada instrução do programa. Isso ocorre porque as instruções NOPs adicionais
levam mais tempo para serem concluídas e, portanto, afetam o desempenho geral do processador.
Resumindo, os resultados mostram que é importante considerar não apenas o CPI mínimo, que
é considerado como o CPI ideal, mas também outros fatores que afetam o desempenho do processador
na prática. É importante identificar e resolver dependências de dados, saltos e outras limitações para
otimizar o desempenho e maximizar a eficiência do processador.

6
Exercício 2
Reordenando as instruções, rescreva o programa para minimizar o tempo de execução do novo
programa, em ciclos de relógio. Compare com o valor obtido no exercício 1. e comente.
Resolução:
Para minimizar o tempo de execução do programa, podemos reorganizar as instruções de
forma a evitar empates (stalls) e maximizar o paralelismo entre as instruções. Abaixo está a
reordenação proposta, comparada a instrução inicial:

Instrução inicial Instrução reordenada

1. mov $s1, $0 1. mov $s0, -1024
2. mov $s2, $0 2. mov $s1, $0
3. mov $s0, -1024 3. mov $s1, $0
4. soma: 4. soma:
5. lw $t0, 0xC400($s0) 5. lw $t0, 0xC400($s0)
6. nop 6. nop
7. nop 7. nop
8. addu $s1, $s1, $t0 8. addu $s1, $s1, $t0
9. nop 9. addu $s2, $s2, $s1
10. sw $s1, 0xE400($s0) 10. sw $s1, 0xE400($s0)
11. nop 11. addiu $s0, $s0, +4
12. addu $s2, $s2, $s1 12. bne $s0, $0, soma
13. addiu $s0, $s0, +4 13. nop
14. bne $s0, $0, soma 14. mov $s1, $0
15. nop
16. mov $s1, $0

Como podemos observar, temos uma nova sequência de instruções a direita, e com elas,
podemos introduzir novos conceitos, como o conceito de que um conjunto de intruções simples,
ou seja, que não têm um alto custo de execução e que não causam nenhum atraso ou empates na
execução do programa, podem ser executados em um único ciclo de clock, como é o exemplo das
três primeiras alíneas. As alíneas 8 e 9 são executadas de forma “paralela” e podemos executar ambas
em um único ciclo também.

7
 Com esse novo conjunto de instruções, se realizassemos o mesmo processo (Que é contar o
número de ciclos por instrução, com base nas novas regras citadas acima, e dividir pelo número de
intruções) para o cálculo do CPI efetivo teriamos um CPI de 1.92 ciclos por instruções.
Tempo de execução
O tempo de execução é uma métrica usada para calcular o desempenho de um processador.
O tempo de execução é a quantidade de tempo que um programa leva para ser executado em um
processador e é medido em unidades de tempo, como segundos ou com mais frequência em
nanosegundos e por ciclos de clock do processador.
Ele pode ser determinado pelas seguintes fórmulas:
1. Tempo de execução = Número de instruções * CPImédio * Período
2. Tempo de execução = (Número de intruções * CPImédio) / frequência

Com estás fórmulas, nós temos como encontrar tempo de execução, mas, por mais que
tenhamos o número de instruções e o CPImédio que é de 1.92, ainda assim, como não nos foi
informado qual a frequência ou o período, não temos como calcular o tempo de execução, mas
conseguimos notar algo que é igualmente útil, que é a relação entre o tempo de execução e o CPImédio,
nós conseguimos notar que os dois são diretamente proporcionais, ou seja, elas variam na mesma
direção e mantêm uma relação constante entre si. Em outras palavras, se uma aumenta, a outra também
aumenta na mesma proporção, e se uma diminui, a outra também diminui na mesma proporção.
Tendo em conta está analogia, podemos comparar o CPI efetivo calculado no exercício
anterior, que é igual a 2.26 ao CPI encontrado com a instrução reordenada, que é igual a 1.92.
Podemos, claramente, ver que o CPI encontrado nesta nova instrução é menor e com isso, podemos
deduzir que o tempo de execução desta nova instrução é muito menor, chegando então a
conclusão que a instrução reordenada, que eliminou algumas depêndencias de dados, evitando
hazards e outros tipos de condições adversas, é muito mais efetivo e performático.