0% acharam este documento útil (0 voto)

3 visualizações138 páginas

Organização e Arquitetura de Computadores

O documento aborda o Capítulo 2 do livro 'Computer Organization and Design RISC-V', focando em abstrações e tecnologias computacionais. Discute conceitos fundamentais como conjuntos de instruções, arquitetura de computadores, e a evolução entre CISC e RISC, além de apresentar exemplos práticos de operações e endereçamento no RISC-V. O conteúdo é voltado para estudantes de Engenharia de Computação e Sistemas Digitais da Escola Politécnica da USP.

Enviado por

Kirby Gamer

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

0% acharam este documento útil (0 voto)

3 visualizações138 páginas

Organização e Arquitetura de Computadores

Enviado por

Kirby Gamer

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

PCS3612: Organização e Arquitetura de Computadores I

Instruções: A Linguagem dos Computadores - Cap 2

Profa. Dra. Cíntia Borges Margi

PCS - Departamento de Engenharia de Computação e Sistemas Digitais

Escola Politécnica da Universidade de São Paulo

[Link]

PCS 3612 - 2025 © CBM

Livro texto

● Capítulo 2: Abstrações e Tecnologias ○ 2.10 Endereçamento no RISC-V

Computacionais ○ 2.11 Paralelismo e instruções:
○ “Computer Organization and Design RISC-V Sincronização
Edition: The Hardware Software Interface”, ○ 2.12 Traduzindo e iniciando um programa
David A. Patterson & John L. Hennessy, 2ª
○ 2.13 Um exemplo de ordenação em C
edição (28 abril 2021), Morgan Kaufmann
para juntar tudo isso
○ 2.14 Arrays versus ponteiros
● Tópicos: ○ 2.15 Material avançado: Compilando C e
○ 2.1 Introdução Interpretando Java
○ 2.2 Operações do hardware do computador ○ 2.16 Vida real: instruções MIPS
○ 2.3 Operandos do hardware do computador ○ 2.17 Vida real: instruções ARMv7 (32 bits)
○ 2.4 Números com sinal e sem sinal ○ 2.18 Vida real: instruções ARMv8 (64 bits)
○ 2.5 Representando instruções no computador ○ 2.19 Vida real: Instruções x86
○ 2.6 Operações lógicas ○ 2.20 Vida real: Demais Instruções RISC-V
○ 2.7 Instruções para tomada de decisões ○ 2.21 Multiplicação de matrizes em Python
○ 2.8 Suporte a procedimentos no hardware do ○ 2.22 Falácias e armadilhas
computador ○ 2.23 Comentários finais
○ 2.9 Comunicando-se com as pessoas

2
PCS 3612 - 2025 © CBM
Introdução
Seção 2.1 do livro-texto

3
PCS 3612 - 2025 © CBM
Conjunto de instruções

● É o vocabulário dos comandos entendidos por uma determinada arquitetura

● Diferentes computadores possuem diferentes conjuntos de instruções
○ Mas com muitos aspectos em comum!
○ Diferentes implementações para um mesmo ISA
● Os primeiros computadores tinham conjuntos de instruções simples
○ Simplifica a implementação
● Muitos computadores modernos também possuem conjuntos de instruções
simples

4
PCS 3612 - 2025 © CBM
Conjunto de instruções RISC-V

● Usado como exemplo no livro texto

● Desenvolvido na UC Berkeley como ISA aberta
● Atualmente é gerenciado pela RISC-V Foundation ([Link]
● Instruções típicas de muitas ISAs modernas
● Veja o cartão RISC-V Reference Data
● ISAs similares possuem parte maior do mercado de embarcados
● Aplicações em eletrônica para consumidor, equipamentos de rede e
armazenamento, câmeras, impressoras, …

5
PCS 3612 - 2025 © CBM
Conceito de Programa Armazenado
e Arquiteturas Associadas

6
PCS 3612 - 2025 © CBM
Conceito de Programa Armazenado
e Arquiteturas Associadas

● Referências:
○ Arquitetura e organização de computadores, William Stallings, Editora Pearson, 8a edição,
2010.
■ Capítulo 1 e 2.
○ First Draft of a Report on the EDVAC. John von Neumann, distributed by Herman Goldstine.
1945.
■ Arquivo pdf disponível no Ae.
○ Livro texto: Seção 1.13 Historical Perspectives & Further Reading
■ Disponível online em
[Link]
○ Livro texto: Seção 2.24 Historical Perspectives & Further Reading
■ [Link]

7
PCS 3612 - 2025 © CBM
Organização e Arquitetura

● Arquitetura de computador: atributos de um sistema visíveis a um

programador
○ Possuem impacto direto sobre a execução lógica de um programa
○ Ex: conjunto de instruções, número de bits para representar dados, modos de endereçamento
à memória.
● Organização de computador: refere-se às unidades operacionais e suas
interconexões, que realizam as especificações arquiteturais.
○ Ex.: sinais de controle, interfaces, tecnologias

8
PCS 3612 - 2025 © CBM
ENIAC (Electronic Numerical Integrator
and Computer)

● Primeiro computador digital eletrônico

de grande escala
○ John Eckert e John Mauchly, Univ. da
Pensilvânia
○ Concluído em 1946
● Programar o ENIAC implicava em
conectar fios, relês e sequências de
chaves para que se determinasse a
tarefa a ser executada
● A cada tarefa diferente a ser executada
pelo ENIAC, é necessário refazer a
programação manual...
Fonte: [Link]

9
PCS 3612 - 2025 © CBM
Ideia

● Desenvolver uma maneira de armazenar os programas na memória, de

maneira similar aos dados (armazenados nos 20 acumuladores)
● Conceito de Programa Armazenado
○ Atribuída a John von Neumann, e desenvolvida simultaneamente por Alan Turing
“In 1944, John von Neumann was attracted to the ENIAC project. The group wanted to improve the way
programs were entered and discussed storing programs as numbers; von Neumann helped crystallize
the ideas and wrote a memo proposing a stored-program computer called EDVAC (Electronic Discrete
Variable Automatic Computer). Herman Goldstine distributed the memo and put von Neumann’s name
on it, much to the dismay of Eckert and Mauchly, whose names were omitted. This memo has served
as the basis for the commonly used term von Neumann computer. Several early pioneers in the
computer field believe that this term gives too much credit to von Neumann, who wrote up the ideas,
and too little to the engineers, Eckert and Mauchly, who worked on the machines. For this reason, the
term does not appear elsewhere in this book or CD.”
David A. Patterson & John L. Hennessy, 2009.

10
PCS 3612 - 2025 © CBM
Princípios e Arquitetura de Von Neumann

● Simplicidade: Operações
elementares sobre operandos
elementares
● Linearidade e Uniformidade:
Memória linear e uniforme
● Sequencialidade e Centralidade:
Processamento sequencial e
controle centralizado
● Unicidade: Programa e dados
armazenados numa mesma
memória

Única memória para dados e instruções!

Único barramento de acesso a memória, que não pode ocorrer
simultaneamente por FD e UC! 11
PCS 3612 - 2025 © CBM
Interpretador de Instruções

● Todo Sistema Digital (SD) programável executa um algoritmo de interpretação

de comandos (instruções)
● Este algoritmo é estruturado como um “loop” contínuo, e é chamado de
interpretador do SD
● As fases básicas deste interpretador são:
○ Busca de instrução
○ Cálculo de endereço e busca de operandos
○ Execução da instrução e armazenamento de resultados

12
PCS 3612 - 2025 © CBM
Interpretador de instruções

13
PCS 3612 - 2025 © CBM
Arquitetura Harvard

● Possui duas memórias diferentes e

independentes em termos de barramento
e ligação ao processador
○ Memória de dados
○ Memória de Instruções
● Projetada para o Harvard Mark I
○ Computador baseado em relés
○ Uso de cartões perfurados
○ Pronto em fev/1944

14
PCS 3612 - 2025 © CBM Fonte: [Link]
Arquitetura Harvard

● Atualmente usada em:

○ Digital signal processors (DSPs)
○ Microcontroladores: memória de programa (flash) e dados (SRAM), sem cache
● Processadores modernos (ARM, x86) usam Harvard Modificada:
○ Cache nível 1 (L1) separado para dados e instruções
○ Acesso a memória principal através de barramento comum

15
PCS 3612 - 2025 © CBM
Organização

● Algumas organizações básicas:

○ Acumulador
○ Pilha
○ Memória/memória
○ Registrador/Memória
○ Load/store
● Podem ser usadas isoladamente ou em conjunto, conforme evolução dos
projetos

16
PCS 3612 - 2025 © CBM
Como fica o código C = A + B nas diferentes
organizações?

17
PCS 3612 - 2025 © CBM
Comparando as organizações

18
PCS 3612 - 2025 © CBM
Evolução

19
PCS 3612 - 2025 © CBM
CISC (Complex Instruction Set Computer)

● Complexo = grande quantidade de ● Exemplos de instruções:

instruções, com múltiplos modos de ○ CAS - compare and swap operands
○ RTR - return and restore codes
endereçamento
○ SWAP - swap register words
● Contexto: memória era cara e pequena → ● Formato de dois operandos mais comum
códigos gerados pelos compiladores ○ ex: ADD CX, mem
deveriam ser compactos e eficientes na ● Modos registrador-registrador;
execução registrador-memória e
● Conceito de microprogramação (1951) memória-registrador.
facilita o projeto de instruções complexas ● Múltiplos modos de endereçamento
○ microcódigo reside em memória de ● Instruções com largura variável
controle ● Instruções requerem múltiplos ciclos de
relógio para sua complexa execução
(variável)
● Hardware possui poucos registradores

20
PCS 3612 - 2025 © CBM
RISC (Reduced Instruction Set Computer)

● Pequeno conjunto de instruções

● Todas as instruções têm tamanho fixo
● Execução otimizada de chamada de
funções (Call / Return)
● Poucos modos de endereçamento
● Controle por hardware
● Execução rápida de cada instrução (1
por ciclo do relógio)

21
PCS 3612 - 2025 © CBM
CISC x RISC?

● Atualmente a distinção não é mais clara

● Melhorias na tecnologia
● Memórias com maior capacidade
● Compiladores modernos eficientes
● Mudança da lógica de controle em “arquiteturas CISC” com uso de conceitos
de otimização de desempenho “RISC”

22
PCS 3612 - 2025 © CBM
Operações do hardware do computador
Seção 2.2 do livro-texto

23
PCS 3612 - 2025 © CBM
Operações Aritméticas

● Add e sub
○ Três operandos: duas origens e um destino

add a, b, c → a = b + c

● Todas operações aritméticas tem a mesma forma

● Princípio de Projeto 1: simplicidade favorece a regularidade
○ Regularidade torna implementação mais simples
○ Simplicidade permite desempenho maior a custo menor

24
PCS 3612 - 2025 © CBM
Exemplo

● Código em C:

f = (g + h) - (i + j);

● Código compilado RISC-V:

add t0, g, h // temp t0 = g + h

add t1, i, j // temp t1 = i + j
sub f, t0, t1 // f = t0 - t1

25
PCS 3612 - 2025 © CBM
Operandos do hardware do computador
Seção 2.3 do livro-texto

26
PCS 3612 - 2025 © CBM
Registradores como operandos

● Instruções aritméticas usam registradores como operandos

● RISC-V tem um conjunto de 32 registradores de 32 bits
○ Usados para dados acessados frequentemente
○ Numerados de 0 a 31: x0 a x31
○ Dados de 32 bits são chamados word
○ Dados de 64 bits são chamados “doubleword”
● MIPS tem um conjunto de 32 registradores de 32 bits
● Princípio de Projeto 2: menor é mais rápido
○ comparado a memória principal com milhões de locais
○ mais registradores podem aumentar o ciclo de clock

27
PCS 3612 - 2025 © CBM
Registradores RISC-V

● x0: a constante valor 0

● x1: return address
● x2: stack pointer
● x3: global pointer
● x4: thread pointer
● x5 – x7, x28 – x31: temporários
● x8: frame pointer
● x9, x18 – x27: saved registers
● x10 – x11: function arguments/results
● x12 – x17: function arguments

28
PCS 3612 - 2025 © CBM
Exemplo

Código em C:

f = (g + h) - (i + j);

f, …, j em x19, x20, …, x23

Código compilado RISC-V:

add x5, x20, x21

add x6, x22, x23

sub x19, x5, x6

29
PCS 3612 - 2025 © CBM
Operandos em memória

● Memória principal usada para estruturas de dados complexas

○ Arrays, structures, dynamic data
● Para apĺicar operações aritméticas
○ Carrega (load) valores da memória para registradores
○ Armazena (store) resultado do registrador para memória
● Memória é endereçada por byte
○ Cada endereço identifica um 8-bit byte
● RISC-V é Little Endian
○ byte menos significativo no endereço menos significativo da palavra
● RISC-V não requer alinhamento de palavras na memória
○ MIPS requer palavras (words) alinhadas na memória

30
PCS 3612 - 2025 © CBM
Exemplo

● Código em C:

A[12] = h + A[8];
h em x21,
endereço base de A em x22
● Código compilado RISC-V:

lw x9, 32(x22) endereçamento por byte → 8 x 4 bytes → 32 no offset

add x9, x21, x9
sw x9, 48(x22) endereçamento por byte → 12 x 4 bytes → 48 no offset

31
PCS 3612 - 2025 © CBM
Registradores e Memória

● Registradores têm acesso mais rápidos do que memória

● Operação em dados na memória requer loads e stores
○ Mais instruções a serem executadas
● Compilador deve usar registradores para variáveis tanto quanto possível
○ Somente “derramar” para memória variáveis usadas menos frequentemente
○ Otimização de registrador é importante!

32
PCS 3612 - 2025 © CBM
Constantes ou operandos imediatos

● Dado constante especificado na própria instrução

addi x22, x22, 4

● Torne o caso comum rápido

○ Constantes pequenas são comuns
○ Operandos imediatos evitam instrução de load

33
PCS 3612 - 2025 © CBM
Números com sinal e sem sinal
Seção 2.4 do livro-texto

O conteúdo desta seção é parte de Sistemas

Digitais, e portanto não será abordado em aula.
Em caso de dúvidas, perguntem!

34
PCS 3612 - 2025 © CBM
Extensão de sinal

● Representar um número usando mais bits

○ Preserva o valor numérico
● Replica o bit de sinal à esquerda
○ valores sem sinal (unsigned): extensão com 0
● Examples: 8-bit para 16-bit
○ +2: 0000 0010 => 0000 0000 0000 0010
○ –2: 1111 1110 => 1111 1111 1111 1110
● No conjunto de instruções RISC-V:
○ lb: sign-extend loaded byte
○ lbu: zero-extend loaded byte

35
PCS 3612 - 2025 © CBM
Representando instruções no computador
Seção 2.5 do livro-texto

36
PCS 3612 - 2025 © CBM
Representando instruções

● Instruções são codificadas em binário

○ chamado linguagem (ou código) de máquina
● Instruções RISC-V
○ Codificadas como palavras de instrução de 32 bits
○ Pequeno número de formatos codificando código de operação (operation code - opcode),
número do registrador, …
○ Regularidade!

FIGURE 2.5 RISC-V instruction encoding.

37
PCS 3612 - 2025 © CBM
RISC-V: Instrução formato R

● opcode: código da operação

● rd: número do registrador destino
● funct3: código de função de 3 bits (opcode adicional)
● rs1: número do primeiro registrador de origem
● rs2: número do segundo registrador de origem
● funct7: código de função de 7 bits (opcode adicional)

→ dois registradores de origem e um destino

38
PCS 3612 - 2025 © CBM
Exemplo de instrução formato R

39
PCS 3612 - 2025 © CBM
RISC-V: Instrução formato I

● Instruções aritméticas com imediato e load

○ rs1: número do registrador de origem ou endereço base
○ immediate: constante ou offset adicionado ao endereço base
■ complemento de 2, extensão de sinal
○ rd: número do registrador destino

→ 1 registrador origem é substituído imediato

● Princípio de Projeto 3: Um bom projeto implica em bons compromissos

○ Formatos diferentes complicam a decodificação, mas permitem instruções uniformes de 32 bits
○ Manter os formatos o mais similar possível

40
PCS 3612 - 2025 © CBM
RISC-V: Instrução formato S

● Formato de instrução com imediato diferente para instruções de store

○ lê registrador e escreve na memória → não preciso de rd!
● rs1: número do registrador de endereço base
● rs2: número do registrador de origem
● immediate: offset adicionado ao endereço base
○ dividido para que campos rs1 e rs2 estejam sempre no mesmo lugar

41
PCS 3612 - 2025 © CBM
Programas armazenados

● Instruções representadas em binário

● Instruções e dados armazenados em memória
● Programas podem operar em programas
○ ex. compiladores, montadores, …
● Compatibilidade binária permitem que programas
compilados funcionem em computadores
diferentes
○ Conjunto de instruções (ISAs) padronizados

42
PCS 3612 - 2025 © CBM
Operações lógicas
Seção 2.6 do livro-texto

43
PCS 3612 - 2025 © CBM
Operações lógicas

FIGURE 2.8 C and Java logical operators and their corresponding RISC-V instructions.
One way to implement NOT is to use XOR with one operand being all ones (FFFF FFFF FFFF FFFFhex). 44

PCS 3612 - 2025 © CBM

Operações

Shift ● AND
○ útil para mascarar bits em uma palavra
● Instrução formato I ● OR
● imediato: quantas posições deslocar ○ útil para incluir bits em uma palavra
● Shift left logical ● XOR
○ Desloca à esquerda e preenche com bits 0 ○ útil para diferenciar bits
○ slli por i bits equivale a multiplicar por 2i
● Shift right logical
○ Desloca à direita e preenche com bits 0
○ srli por i bits equivale a dividir por 2i
(somente números sem sinal!)

45
PCS 3612 - 2025 © CBM
Instruções para tomada de decisões
Seção 2.7 do livro-texto

46
PCS 3612 - 2025 © CBM
Operações condicionais

● Desvia para instrução com rótulo se condição é verdade

○ Caso contrário, continue sequencialmente
● beq r1, r2, L1
○ se (r1 == r2) desvie para instrução rotulada L1
● bne r1, r2, L1
○ se (r1 != r2) desvie para instrução rotulada L1

47
PCS 3612 - 2025 © CBM
Compilando if

● Código RISC-V compilado:

bne x22, x23, Else

add x19, x20, x21

beq x0,x0,Exit // unconditional

● Código em C: Else: sub x19, x20, x21
if (i==j) f = g+h; Exit: …
else f = g-h;

f, g, … in x19, x20,… Assembler calcula endereços

48
PCS 3612 - 2025 © CBM
Compilando while (loop)

Código em C: Compiled RISC-V code:

dados de 32 bits,
while (save[i] == k) i += 1; Loop: slli x10, x22, 2 multiplica por 4 (2^2)

● i em x22 e k em x24 add x10, x10, x25

● endereço base em x25
lw x9, 0(x10)

bne x9, x24, Exit

addi x22, x22, 1

beq x0, x0, Loop

Exit: …

49
PCS 3612 - 2025 © CBM
Blocos básicos

● Um bloco básico é uma sequência de instruções

○ sem desvios embutidos (exceto no final)
○ sem alvos de desvio - branch targets (exceto no início)
● Um compilador identifica blocos básicos para otimização
● Um processador avançado pode acelerar a execução de blocos básicos

50
PCS 3612 - 2025 © CBM
Mais operações condicionais

● blt rs1, rs2, L1

○ se (rs1 < rs2) desvie para instrução rotulada L1
● bge rs1, rs2, L1
○ se (rs1 >= rs2) desvie para instrução rotulada L1
● Exemplo:
if (a > b) a += 1;
a in x22, b in x23
bge x23, x22, Exit // branch if b >= a
addi x22, x22, 1
Exit:

51
PCS 3612 - 2025 © CBM
Signed vs. Unsigned

● Comparação com sinal (signed): blt, bge

● Comparação sem sinal (unsigned): bltu, bgeu
● Exemplo:
○ x22 = 1111 1111 1111 1111 1111 1111 1111 1111
○ x23 = 0000 0000 0000 0000 0000 0000 0000 0001
○ x22 < x23 // signed
○ –1 < +1
○ x22 > x23 // unsigned
○ +4,294,967,295 > +1

52
PCS 3612 - 2025 © CBM
53
PCS 3612 - 2025 © CBM
RISC-V (continuação)

54
PCS 3612 - 2025 © CBM
Suporte a procedimentos no hardware do
computador
Seção 2.8 do livro-texto

55
PCS 3612 - 2025 © CBM
Procedimento

● Ou função
● Forma de implementar abstração no software
● É uma sub-rotina armazenada que realiza uma tarefa com base nos
parâmetros que lhe são passados

56
PCS 3612 - 2025 © CBM
Passos necessários

1. Colocar parâmetros em um lugar onde o procedimento possa acessá-los

(registradores x10 a x17)
2. Transferir o controle para o procedimento
3. Adquirir os recursos de armazenamento necessários para o procedimento
4. Realizar a tarefa desejada
5. Colocar o valor de retorno em um local onde o programa que o chamou possa
acessá-lo
6. Retornar o controle para o ponto de origem

57
PCS 3612 - 2025 © CBM
Instruções para chamada

● Chamada de procedimento: jump and link

jal x1, ProcedureLabel
○ Endereço da próxima instrução colocado em x1
○ Salta para o endereço alvo
● Retorno do procedimento: jump and link register

jalr x0, 0(x1)

○ Similar a jal, mas salta para 0 + endereço em x1
○ Usa x0 como rd (x0 não pode ser mudado)
○ Também pode ser usado para saltos calculados
■ ex. instruções case/switch

58
PCS 3612 - 2025 © CBM
Uso de registradores

● x5 – x7, x28 – x31: registradores temporários

○ não são preservados pelo procedimento chamado
■ procedimento chamado ou callee: um procedimento que executa uma série de instruções
armazenadas com base nos parâmetros fornecidos pelo caller e depois retorna o controle
para o caller novamente.
● x8 – x9, x18 – x27: registradores salvos
○ Se usados, o procedimento chamado salva no início e restaura no final

59
PCS 3612 - 2025 © CBM
Exemplo - procedimento folha

● Código em C:
int leaf_example (int g, int h, int i, int j)
{
int f;
f = (g + h) - (i + j);
return f;
}
● Argumentos g, … , j em x10, …, x13
● f em x20
● temporários x5, x6
● Precisa salvar x5, x6, x20 na pilha

60
PCS 3612 - 2025 © CBM
Exemplo - procedimento folha

● Código em C: Código RISC-V:

leaf_example:
int leaf_example (int g, int h, int i, int j)
addi sp,sp,-12 salva x5, x6, x20 na pilha
{ sw x5,8(sp)
int f; sw x6,4(sp)
f = (g + h) - (i + j); sw x20,0(sp)
return f; add x5,x10,x11 x5 = g + h
} add x6,x12,x1 x6 = i + j
sub x20,x5,x6 f = x5 - x6
● Argumentos g, … , j em x10, …, x13
addi x10,x20,0 copia f para registrador retorno
● f em x20 lw x20,0(sp) restaura x5, x6, x20 da pilha
● temporários x5, x6 lw x6,4(sp)
● Precisa salvar x5, x6, x20 na pilha lw x5,8(sp)
addi sp,sp,12
jalr x0,0(x1) retorna ao ponto de chamada

61
PCS 3612 - 2025 © CBM
Dados na pilha

FIGURE 2.10 The values of the stack pointer and the stack (a) before, (b) during, and © after the procedure call.
The stack pointer always points to the “top” of the stack, or the last word in the stack in this drawing.

62
PCS 3612 - 2025 © CBM
Procedimentos aninhados

● Procedimentos que chamam outros procedimentos

● Procedimento que chama precisa salvar na pilha:
○ seu endereço de retorno
○ quaisquer argumentos e registradores temporários que podem ser necessários depois da
chamada
● Restaura da pilha depois da chamada

63
PCS 3612 - 2025 © CBM
Exemplo - Procedimento aninhado

Código RISC-V:
Código em C: fact:
int fact (int n) addi sp,sp,-8 Salva endereço de retorno e n na pilha
{ sw x1, 4(sp)
sw x10, 0(sp)
if (n < 1) return f; addi x5, x10, -1 x5 = n -1
else return n * fact(n - 1); bge x5, x0, L1 if n>=1, vá para L1
} addi x10, x0, 1 senão, valor de retorno é 1
addi sp, sp, 8 Libera a pilha, não restaura valores
jalr x0, 0(x1) Retorna
Argumento em x10
L1: addi x10,x10,-1 n = n -1
Resultado em x10 jal x1,fact chama fact(n-1)
addi x6,x10,0 move resultado de fact(n-1) para x6
lw x10,0(sp) restaura n de quem chamou
lw x1,4(sp) restaura endereço de quem chamou
addi sp,sp,8 libera pilha (pop)
mul x10,x10,x6 retorna n*fact(n-1)
jalr x0,0(x1) retorna 64
PCS 3612 - 2025 © CBM
O que deve ser preservado?

FIGURE 2.11 What is and what is not preserved across a procedure call. If the software relies on the global
pointer register, discussed in the following subsections, it is also preserved.

65
PCS 3612 - 2025 © CBM
Alocação da pilha

frame pointer (fp): um valor indicando o local dos registradores salvos e as variáveis
locais para um determinado procedimento.

FIGURE 2.12. Ilustração da alocação de pilha (a) antes, (b) durante e (c) após a chamada de um procedimento.
O frame pointer ($fp) aponta para a primeira palavra do frame, normalmente um registrador de argumento salvo, e o stack pointer ($sp) aponta para o topo da pilha.
A pilha é ajustada de modo a criar espaço para todos os registradores salvos e quaisquer variáveis locais residentes na memória. Como o stack pointer pode mudar
durante a execução do programa, é mais fácil para os programadores referenciarem variáveis por meio do frame pointer estável, embora isso também pudesse ser
feito por meio do stack pointer e um pouco de aritmética de endereços. Se não houver variáveis locais na pilha dentro de um procedimento, o compilador ganhará
tempo não atribuindo um endereço ao frame pointer, e depois, restaurando-o. Quando um frame pointer é usado, ele é inicializado usando o endereço que está no
$sp em uma chamada, e o $sp é restaurado usando o valor do $fp.
66
PCS 3612 - 2025 © CBM
Alocação de memória

● Text
○ código do programa
● Static data
○ variáveis globais
○ ex. variáveis estáticas em C, constantes,
vetores de tamanho definido
○ x3 (global pointer)
● Dynamic data
○ heap
○ ex. malloc em C, new em Java
● Stack

67
PCS 3612 - 2025 © CBM
Comunicando-se com as pessoas
Seção 2.9 do livro-texto

68
PCS 3612 - 2025 © CBM
Caracteres

FIGURE 2.15 ASCII representation of characters. Note that upper- and lowercase letters differ by exactly 32; this observation
can lead to shortcuts in checking or changing upper- and lowercase. Values not shown include formatting characters. For example,
8 represents a backspace, 9 represents a tab character, and 13 represents a carriage return. Another useful value is 0 for null, the
value the programming language C uses to mark the end of a string.

69
PCS 3612 - 2025 © CBM
RISC-V: Operações load/store

● Load: extensão de sinal para tamanho do registrador em rd

○ lb rd, offset(rs1)
○ lh rd, offset(rs1)
○ lw rd, offset(rs1)
● Load unsigned: extensão com zeros para tamanho do registrador em rd
○ lbu rd, offset(rs1)
○ lhu rd, offset(rs1)
○ lwu rd, offset(rs1)
● Store: armazena os 8/16/32 bits mais à direita
○ sb rs2, offset(rs1)
○ sh rs2, offset(rs1)
○ sw rs2, offset(rs1)

70
PCS 3612 - 2025 © CBM
Exemplo: copiando string

Código em C: Código em RISC-V:

strcpy:
Null-terminated string addi sp,sp,-4 // adjust stack for 1 word
void strcpy (char x[], char y[]) sw x19,0(sp) // push x19
{ size_t i; add x19,x0,x0 // i=0
L1: add x5,x19,x11 // x5 = addr of y[i]
i = 0;
lbu x6,0(x5) // x6 = y[i]
while ((x[i]=y[i])!='\0') add x7,x19,x10 // x7 = addr of x[i]
i += 1; sb x6,0(x7) // x[i] = y[i]
} beq x6,x0,L2 // if y[i] == 0 then exit
addi x19,x19, 1 // i = i + 1
jal x0,L1 // next iteration of loop
x e y em x10 e x11
L2: lw x19,0(sp) // restore saved x19
i em x19 addi sp,sp,4 // pop 1 doubleword from stack
jalr x0,0(x1) // and return

71
PCS 3612 - 2025 © CBM
Endereçamento no RISC-V para
operandos imediatos e endereços
Seção 2.10 do livro-texto

72
PCS 3612 - 2025 © CBM
Constantes de 32 bits

● Maioria das constantes é pequena

○ Imediato de 12 bits é suficiente
● Para constantes de 32 bits: lui rd, constant
○ Copia constante de 20 bits [31:12] de rd
○ Limpa bits [11:0] de rd para 0
● Exemplo: como obter constante 00000000 00111101 00000101 00000000?
lui x19, 976 //976dec=0000 0000 0011 1101 0000
Após, x19=00000000 00111101 00000000 00000000
addi x19, x19, 1280 //1280dec= 0101 00000000
Após, x19=00000000 00111101 00000101 00000000

73
PCS 3612 - 2025 © CBM
Endereço de desvios condicionais

● Instruções de desvios condicionais (branch) especificam:

○ Opcode, dois registradores, endereço alvo
○ maioria dos alvos é próxima a instrução
■ para frente ou para trás
● Formato SB:

● Endere relativo ao PC:

○ Endereço alvo = PC + imediato × 2

74
PCS 3612 - 2025 © CBM
Endereço de saltos (jump)

● Alvo de jump and link (jal) usa imediato de 20 bits para maior alcance
● Formato UJ:

● Para saltos maiores

○ Ex. para endereço absoluto de 32 bits
○ lui: load address[31:12] para registrador temporário
○ jalr: add address[11:0] e jump

75
PCS 3612 - 2025 © CBM
RISC-V: Modos de endereçamento

76
PCS 3612 - 2025 © CBM
RISc-V: formatos de instrução

FIGURE 2.19 Four RISC-V instruction formats. Figure 4.14.6 reveals the missing RISC-V formats for conditional branch (SB) and unconditional jumps (UJ),
whose formats match the lengths of the fields in the S and U types, but the bits are swirled around. The rationale for SB and UJ makes more sense once you
have an understanding of hardware given in Chapter 4, as SB and UJ simplify the hardware but give the assembler a little more to do.

77
PCS 3612 - 2025 © CBM
Sincronização
Seção 2.11 do livro-texto

78
PCS 3612 - 2025 © CBM
Sincronização

● Considere 2 processos compartilhando área na memória: P1 escreve, e P2 lê

● Resultado final irá depender da ordem de acesso de escrita e leitura
○ Data race se P1 e P2 não sincronizam!
● Requer suporte do hardware
○ operações atômicas de leitura/escrita
○ Nenhum outro acesso ao local permitido entre leitura e escrita
● Poderia ser uma instrução única
○ Ex.: troca entre registrador e memória atômica
○ Ou um par de instruções atômico

79
PCS 3612 - 2025 © CBM
Sincronização no RISC-V

● Load reserved: lr.d rd,(rs1)

○ Load do endereço em rs1 para rd
○ Coloca uma reserva no endereço de memória
● Store conditional: sc.d rd,(rs1),rs2
○ Armazena de rs2 para endereço em rs1
○ Sucesso de não ocorreu mudança no local desde o lr.d
■ Retorna 0 in rd
○ Falha se local mudou
■ Retorna valor não zero em rd

80
PCS 3612 - 2025 © CBM
Exemplo

● Troca atômica (to test/set lock variable)

again: lr.w x10,(x20)

sc.w x11,x23,(x20) // X11 = status

bne x11,x0,again // branch if failed

addi x23,x10,0 // X23 = loaded value

81
PCS 3612 - 2025 © CBM
Traduzindo e iniciando um programa
Seção 2.12 do livro-texto

82
PCS 3612 - 2025 © CBM
Hierarquia de tradução para C

Pode ser um passo só

Estático

FIGURE 2.20 A translation hierarchy for C. A high-level language program is first compiled into an assembly language program and then assembled into an
object module in machine language. The linker combines multiple modules with library routines to resolve all references. The loader then places the machine code
into the proper memory locations for execution by the processor. To speed up the translation process, some steps are skipped or combined. Some compilers
produce object modules directly, and some systems use linking loaders that perform the last two steps. To identify the type of file, UNIX follows a suffix convention
for files: C source files are named x.c, assembly files are x.s, object files are named x.o, statically linked library routines are x.a, dynamically linked library routes
are [Link], and executable files by default are called [Link]. MS-DOS uses the suffixes .C, .ASM, .OBJ, .LIB, .DLL, and .EXE to the same effect.
83
PCS 3612 - 2025 © CBM
Produzindo um objeto

● Assembler traduz o programa para instruções de máquina

● Provê informações para construir o programa completo:
○ Header: conteúdo do módulo objeto
○ Segmento de texto: instruções traduzidas
○ Segmento de dados estático: toda duração
○ Info de relocação: para conteúdo que depende de referências absolutas do programa
carregado
○ Tabela de símbolos: definições globais e referências externas
○ Info de debug: para associar a código fonte

84
PCS 3612 - 2025 © CBM
Ligando objetos (estático)

● Produz imagem executável

○ 1. Junta segmentos
○ 2. Resolve rótulos (determina endereços)
○ 3. Corrige referências dependentes de local e externas

85
PCS 3612 - 2025 © CBM
Carregando um programa

● Carrega imagem do disco para memória

○ 1. Lê header para obter tamanho de segmentos
○ 2. Cria espaço de endereçamento virtual
○ 3. Copia segmento de texto e inicializa dados
○ 4. Coloca argumentos na pilha
○ 5. Inicializa registradores (inclusive $sp, $fp, $gp)
○ 6. Salta para rotina inicial
■ copia argumentos para x10, … e chama main
■ quando main sair, faz exit syscall

86
PCS 3612 - 2025 © CBM
Ligações dinâmicas

● Somente liga/carrega (link/load) procedimentos da biblioteca quando for

chamada
○ Requer que o código do procedimento seja relocável
○ Evita “inchaço” da imagem causado por ligações estáticas de todas as bibliotecas
referenciadas
○ Automaticamente atualiza novas versões de bibliotecas
● Versões iniciais ligavam todas as rotinas da biblioteca!
○ atualmente “lazy procedure” → somente após chamar a rotina que esta é ligada.

87
PCS 3612 - 2025 © CBM
DLLs e lazy procedure

FIGURE 2.21 Dynamically linked library via lazy procedure

linkage.
(a) Steps for the first time a call is made to the DLL routine.
(b) The steps to find the routine, remap it, and link it are skipped on
subsequent calls.
As we will see in Chapter 5, the operating system may avoid copying
the desired routine by remapping it using virtual memory management.
88
PCS 3612 - 2025 © CBM
Iniciando aplicações em Java

FIGURE 2.22 A translation hierarchy for Java.

A Java program is first compiled into a binary version of Java bytecodes, with all addresses defined by the compiler.
The Java program is now ready to run on the interpreter, called the Java Virtual Machine (JVM).
The JVM links to desired methods in the Java library while the program is running. To achieve greater performance, the JVM can invoke the JIT compiler,
which selectively compiles methods into the native machine language of the machine on which it is running.

89
PCS 3612 - 2025 © CBM
Um exemplo de ordenação em C para juntar
tudo
Seção 2.13 do livro-texto

90
PCS 3612 - 2025 © CBM
Exemplo

● Programa completo em assembly equivalente ao bubble sort em C

● Função swap
○ troca elementos
○ é folha
● Função sort
○ Não é folha
○ chama a função swap

Função em C

parâmetros v e k em x10 e x11

swap:
slli x6,x11,2 // reg x6 = k * 4
add x6,x10,x6 // reg x6 = v + (k * 4)
lw x5,0(x6) // reg x5 (temp) = v[k] Código RISC-V
lw x7,4(x6) // reg x7 = v[k + 1]
sw x7,0(x6) // v[k] = reg x7
sw x5,4(x6) // v[k+1] = reg x5 (temp)
jalr x0,0(x1) // return to calling routine
92
PCS 3612 - 2025 © CBM
Função sort

Função em C

parâmetros v e n em x10 e x11

i em x19 e j em x20

Código RISC-V

parâmetros v e n em x10 e x11

i em x19 e j em x20

parâmetros v e n em x10 e x11

i em x19 e j em x20

None: melhor CPI

O1: menor IC
O3: menor Texec

FIGURE 2.26 Comparing performance, instruction count, and CPI using compiler optimization for Bubble Sort.
The programs sorted 100,000 32-bit words with the array initialized to random values. These programs were run on a Pentium 4 with a clock rate of
3.06 GHz and a 533 MHz system bus with 2 GB of PC2100 DDR SDRAM. It used Linux version 2.4.20.

● -O1: reduz tamanho de código e tempo de execução, sem otimizações demoradas

● -O2: além de O1, otimizações que não envolvam space-speed tradeoff
○ aumenta o tempo de compilação e o desempenho do código gerado
● -O3: além de O2 mais otimizações.
Demais otimizações em: [Link]

FIGURE 2.27 Performance of two sort algorithms in C and Java using interpretation and optimizing compilers relative to unoptimized
C version.
The last column shows the advantage in performance of Quicksort over Bubble Sort for each language and execution option.
These programs were run on the same system as in Figure 2.29. The JVM is Sun version 1.3.1, and the JIT is Sun Hotspot version 1.3.1.

● Bubble sort:
○ código em C não otimizado é 8,3 vezes mais rápido do que código em Java interpretado
○ Compilador JIT torna execução em Java 2,1 vezes mais rápida que código em C não
otimizado e desempenho melhor que C otimizado
● Quicksort:
○ diferença de algoritmo predomina, baixo tempo de execução para código compilado

● Contagem de instruções (IC) e CPI não são bons indicadores de desempenho

isoladamente
● Otimizações de compilador são sensíveis ao algoritmo
● Código Java/JIT compilado é significativamente mais rápido do que JVM
interpretado
○ Comparável a C otimizado em alguns casos
● Nada pode corrigir um algoritmo ruim!

99
PCS 3612 - 2025 © CBM
Conteúdo das seções 2.14 (Arrays versus
ponteiros) e 2.15 (Compiling C and Interpreting
Java) não fazem parte do escopo da disciplina

● Projetado na década de 80
● RISC-V possui projeto similar
○ acesso a memória via load/store
○ 32 registradores, sendo um fixo em zero
○ instruções com 32 bits de largura
○ ambos possuem bne e beq
● Principal diferença: instrução de desvio
○ MIPS: somente bne e beq
○ Para outras comparações: usar comparação
■ slt ou sltu
● Conjunto de instruções completo do MIPS é maior do que RISC-V

● ARM = Advanced RISC Machine

● Publicado na mesma época do MIPS e seguiu filosofia similar

FIGURE 2.30 Similarities in ARM and RISC-V instruction sets.

FIGURE 2.31 ARM register–register and data transfer instructions equivalent to the RISC-V core.
Dashes mean the operation is not available in that architecture or not synthesized in a few instructions. If there are several choices of
instructions equivalent to the RISC-V core, they are separated by commas. ARM includes shifts as part of every data operation instruction, so a
shift with superscript 1 is just a variation of a move instruction, such as lsr1. Note that ARM has no divide instruction.

FIGURE 2.32 Summary of data-addressing modes.

ARM has separate register indirect and register + off set addressing modes rather than just putting 0 in the offset of the latter mode. To get
greater addressing range, ARM shifts the offset left 1 or 2 bits if the data size is a halfword or word.

● Descartou características não usadas da v7

○ Não há um campo de execução condicional
○ Campo imediato é uma constante de 12 bits
○ Retirou as instruções load multiple, store multiple
○ PC não é mais um GPR
● Acrescentou recursos:
○ 32 registradores de uso geral (GPR)
○ Modos de endereçamento funcionam para todos os tamanhos de palavra
○ instrução de divisão
○ instruções “branch if equal” e “branch if not equal”
● A única similaridade com ARMv7 é o nome…

● Evolução com compatibilidade

● 8080 (1974): microprocessador 8 bits
○ Acumulador, mais 3 pares index-register
● 8086 (1978): extensão de 16 bits para 8080
○ Complex instruction set (CISC)
● 8087 (1980): coprocessador de ponto flutuante
○ adiciona instruções FP e registradores
● 80286 (1982): endereços de 24 bits, MMU
○ Modelo de mapeamento e proteção de memória
● 80386 (1985): extensão 32 bits (IA-32)
○ Operações e modos de endereçamento adicionais
○ Suporte a paginação, e endereçamento segmentado

● i486 (1989): pipeline, caches e FPU no chip

○ Compatível com: AMD, Cyrix, …
● Pentium (1993): superscalar, fluxo de dados de 64 bits
○ Versões posteriores com instruções MMX
○ FDIV bug
● Pentium Pro (1995), Pentium II (1997)
○ Nova microarquitetura (veja The Pentium Chronicles)
● Pentium III (1999)
○ Adição de SSE (Streaming SIMD Extensions)
● Pentium 4 (2001)
○ Nova microarquitetura
○ Adição de instruções SSE2
● AMD64 (2003): estende arquitetura para 64 bits

● EM64T – Extended Memory 64 Technology (2004)

○ AMD64 adotada pela Intel (com refinamentos)
○ Adição de instruções SSE3
● Intel Core (2006)
○ Adição de instruções SSE4, suporte a máquina virtual
● AMD64 (anunciada em 2007): instruções SSE5
○ Intel não segue, ao invés ...
● Advanced Vector Extension (lançada em 2011)
○ Registradores SSE de 256 bits, mais instruções
● AVX-512 (lançada em 2015)
● Se a Intel não expandisse com compatibilidade os competidores teriam feito!
○ elegância técnica ≠ sucesso de mercado

FIGURE 2.34 The 80386 register set.

Starting with the 80386, the top eight registers were
extended to 32 bits and could also be used as
general-purpose registers.

FIGURE 2.35 Instruction types for the arithmetic, logical, and data transfer instructions.
The x86 allows the combinations shown. The only restriction is the absence of a memory-memory mode. Immediates may be 8, 16, or 32 bits in
length; a register is any one of the 14 major registers in Figure 2.33 (not EIP or EFLAGS).

FIGURE 2.36 x86 32-bit addressing modes with register restrictions and the equivalent RISC-V code. The Base plus Scaled Index
addressing mode, not found in RISC-V or MIPS, is included to avoid the multiplies by 4 (scale factor of 2) to turn an index in a register into a byte
address (see Figures 2.26 and 2.28). A scale factor of 1 is used for 16-bit data, and a scale factor of 2 for 32-bit data. A scale factor of 0 means
the address is not scaled. If the displacement is longer than 12 bits in the second or fourth modes, then the RISC-V equivalent mode would need
more instructions, usually a lui to load bits 12 through 31 of the displacement, followed by an add to sum these bits with the base register. (Intel
gives two different names to what is called Based addressing mode—Based and Indexed—but they are essentially identical and we combine
them here.)

FIGURE 2.38 Some typical operations

on the x86.
Many operations use register-memory
format, where either the source or the
destination may be memory and the other
may be a register or immediate operand.

FIGURE 2.39 Typical x86 instruction formats. Figure 2.39

shows the encoding of the postbyte.
Many instructions contain the 1-bit field w, which says whether
the operation is a byte or a doubleword. The d field in MOV is
used in instructions that may move to or from memory and
shows the direction of the move. The ADD instruction requires
32 bits for the immediate field, because in 32-bit mode, the
immediates are either 8 bits or 32 bits. The immediate field in
the TEST is 32 bits long because there is no 8-bit mode
immediate for test in 32-bit mode. Overall, instructions may
vary from 1 to 15 bytes in length. The long length comes from
extra 1-byte prefixes, having both a 4-byte immediate and a
4-byte displacement address, using an opcode of 2 bytes, and
using the scaled index mode specifier, which adds another
byte.

FIGURE 2.40 The encoding of the first address specifier of the x86: mod, reg, r/m. The first four columns show the encoding of the 3-bit reg
field, which depends on the w bit from the opcode and whether the machine is in 16-bit mode (8086) or 32-bit mode (80386). The remaining
columns explain the mod and r/m fields. The meaning of the 3-bit r/m field depends on the value in the 2-bit mod field and the address size.
Basically, the registers used in the address calculation are listed in the sixth and seventh columns, under mod = 0, with mod = 1 adding an 8-bit
displacement and mod = 2 adding a 16-bit or 32-bit displacement, depending on the address mode. The exceptions are 1) r/m = 6 when mod = 1
or mod = 2 in 16-bit mode selects BP plus the displacement; 2) r/m = 5 when mod = 1 or mod = 2 in 32-bit mode selects EBP plus displacement;
and 3) r/m = 4 in 32-bit mode when mod does not equal 3, where (sib) means use the scaled index mode shown in Figure 2.39. When mod = 3,
the r/m field indicates a register, using the same encoding as the reg field combined with the w bit.

● Complex instruction set (CISC) torna a implementação difícil

○ Hardware traduz instruções para microoperações mais simples
■ instruções simples: 1–1
■ instruções complexas: 1–muitas
○ Microengine similar a RISC
○ Fatia de mercado torna isso economicamente viável
● Desempenho comparável a RISC
○ Compiladores evitam usar instruções complexas

FIGURE 2.41 The remaining five instructions in the base RISC-V instruction set architecture.

FIGURE 2.42 The RISC-V instruction set architecture is divided into the base ISA, named I, and five standard
extensions, M, A, F, D, and C. RISC-V International is developing many other optional instruction extensions. Unlike most
architectures, the RISC-V software stack only assumes the base architecture (I), with other extensions optional that are only
issued by the compiler if the processor includes those options.

● Código em Python

○ sem utilizar bibliotecas otimizadas, pois o objetivo é mostrar as diferenças de linguagens entre
Python e C

FIGURE 2.43 C version of a double-precision matrix multiply, widely known as DGEMM for Doubleprecision GEneral Matrix Multiply (GEMM).

FIGURE 2.44 The x86 assembly language for the body of the nested loops generated by compiling the unoptimized C code in Figure
2.43 using gcc with -O3 optimization flags.
129
PCS 3612 - 2025 © CBM
Desempenho

FIGURE 2.45 Speed of DGEMM in Figure 2.43 over the Python program in Section 1.10 as we increase optimization levels.

● Falácia: instruções mais poderosas significam maior desempenho

○ precisa executar menos instruções
○ mas instruções mais complexas requerem mais tempo de execução devido a complexidade

● Falácia: escreva em assembly para obter maior desempenho

○ Compiladores modernos lidam melhor com com processadores
○ Mais linhas de código → mais erros, menor produtividade

● Falácia: a importância da compatibilidade binária comercial significa que os

conjuntos de instrução bem sucedidos não mudam

FIGURE 2.46 Growth of x86 instruction set over time.

● Armadilha: esquecer que os endereços sequenciais de palavras em máquinas

com endereços em byte não diferem em um
○ incrementar por 4 (se palavra de 32 bits), e não por 1!

● Armadilha: usando um ponteiro para uma variável automática fora do seu

procedimento de definição

● Princípios de projeto
○ simplicidade favorece a regularidade
○ menor é mais rápido
○ um bom projeto exige bons compromissos
● Abstrações: camadas de software/hardware
○ Compilador, assembler, hardware
● RISC-V: exemplo típico de conjunto de instruções RISC
○ diferente do x86
○ similar MIPS e ARM v8

FIGURE 2.48 RISC-V instruction classes, examples, correspondence to high-level program language constructs, and
percentage of RISC-V instructions executed by category for the average integer and floating point SPEC CPU2006
benchmarks. Figure 3.24 in Chapter 3 shows average percentage of the individual RISC-V instructions executed.

Instruções: A Linguagem dos Computadores - Cap 2

Profa. Dra. Cíntia Borges Margi

PCS - Departamento de Engenharia de Computação e Sistemas Digitais

Escola Politécnica da Universidade de São Paulo

[Link]