Resumo GCC194 - Vinicius Teixeira Neiva (1)

Prévia do material em texto

Nome: Vinicius Teixeira Neiva 14A Matrícula: 201710237 
 
● Organização de um computador 
No primeiro vídeo, a aula 5, sobre a organização de um computador, foi dividido esta 
organização em duas partes, a organização e a arquitetura dos computadores. A 
organização relaciona-se com as unidades operacionais e suas interconexões, a 
arquitetura dita os atributos de um sistema. A Arquitetura do Conjunto de Instruções, 
chamado de ISA = Instruction Set Architecture, é o repertório de instruções de um 
computador, nem todos os computadores possuem o mesmo ISA, podem ser 
implementados de maneiras diferentes. 
 
A ISA tem cinco elementos principais : 
1. Repertório de operações 
Quantas e quais são as operações e sua complexidade. Ex: transferência de 
dados, E/S, controle, .. 
2. Tipo e tamanho dos operandos (dados) 
Ex: Arquitetura (8 bits para microcontroladores e 64 bits para a arquitetura 
atual). 
3. Endereçamento dos operandos 
Modos de endereçamento, forma em que os dados irão se relacionar. 
4. Formato de instrução 
Número de operandos (explícitos), tamanho dos bits,... 
5. Armazenamento dos operandos 
Como os operandos são armazenados, seja eles por registrador, memória, 
acumulador,...; e suas características. 
 
Não importa a arquitetura, ela precisa definir todos esses aspectos. 
 
CISC (Complex Instruction Set Computer) 
Nos dias atuais a necessidade de realizar operações complexas aumentou muito, 
algo que era impossível antigamente pois a memória era cara e pequena, o que 
resultava que os códigos gerados pelos compiladores da época deveriam ser 
compactos e eficientes na execução. O conceito de microprogramação (criado em 
1951) facilitou o trabalho de projetar instruções complexas. Hoje um computador é 
capaz de reproduzir grandes quantidade de instruções com múltiplos modos de 
endereçamento. Alguns exemplos de instrução do CISC: 
CAS - compare and swap operands ( compara dois operandos, dependendo 
do resultado troca de lugar os operandos.) 
 
RTR - return and restore codes ( retornar e restaurar códigos) 
 
Cada operação efetua duas ações. 
 
 
 
 
 
CISC: Características de projeto 
 
Formato de dois operandos mais comum a fim de simplificar operações. Ex: ADD 
CX, mem (adiciona o registrador CX a um endereço de memória e armazenar no 
registrador CX ). 
Modos registrador-registrador; registrador-memória e memória-registrador. (Garante 
flexibilidade). 
Múltiplos modos de endereçamento (Também auxilia na flexibilidade). 
Instrução com largura variável. 
Instruções requerem múltiplos ciclos de relógio para sua complexa execução 
(variável). (Ocasiona um tempo de execução maior, mas executa tarefas complexas) 
Hardware possui poucos registradores (Compensado pela flexibilidade). 
 
 
RISC (Reduced Instruction Set Computer) 
 
Pequeno conjunto de instruções 
Todas as instruções tem 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) 
 
No computador RISC podemos ter um alto número de instruções mas o ciclo 
execução costuma ser menor. O número de instruções não é métrica de tempo mas 
sim o tempo de ciclo. No CISC o número de instruções pode ser menor mas o tempo 
de execução maior. 
 
CISC X RISC 
 
Ambas promoveram grandes contribuições para o desenvolvimento e a evolução 
das técnicas. A Intel começou com a implementação CISC mas hoje em dia já não 
utiliza totalmente ela. Foi adotado a mudança da lógica de controle em arquiteturas 
CISC com o uso de conceitos de otimização de desempenho RISC. 
 
● A Linguagem dos computadores 
As palavras da linguagem de um computador são chamadas de instruções e seu 
vocabulário é denominado conjunto de instruções. Como exemplo os conjuntos de 
instruções da MIPS são alguns deles: Intel x86, ARMv7 e ARM v8. 
 
Os objetivos de uma linguagem de máquina são: Oferecer algumas operações 
que todo computador precisa oferecer; Facilitar o projeto do hardware e do 
compilador; maximizar o desempenho e minimizar o custo. 
Programas armazenados são instruções e dados de diversos tipos, podem ser até 
armazenados na memória como números binários. 
 
Princípio de projeto 1:​ Simplicidade favorece a regularidade. 
Fixar o número de operandos resulta numa simplicidade. 
Os operandos das instruções são de um grupo limitado de locais especiais, 
embarcados diretamente no hardware, chamados de ​registradores. ​Na arquitetura 
MIPS o tamanho de um registrador é de 32 bits e um grupo de 32 bits no MIPS é 
chamado de ​word​. 
 
Princípio de projeto 2: ​Menos significa mais rápido. 
Quanto mais registradores tem, maior o tempo de ciclo de clock; 
É necessário atingir um equilíbrio entre a quantidade de registradores utilizada e 
manter o ciclo de clock rápido; 
Ter mais registradores implica em mais bits no formato da instrução para 
endereçá-los. 
Registradores são representados por um cifrão ($) seguido por dois caracteres. 
Ex:$t0. 
 
Operandos em memória 
A quantidade de dados que um registrador suporta é baixa. Arrays e estruturas de 
dados ficam na memória, pois a memória tem capacidade de armazenar milhões de 
elementos de dados. Somente dados que estão alocados nos registradores podem 
ser usados nas operações aritméticas no MIPS. Dentre elas temos: 
● Instruções de transferência de dados, feitas para a transação dos 
dados entre memória e registradores. 
● o acesso a esse dado na memória é através do seu endereço. 
A palavra reservada do MIPS para carregar dados da memória é o “​lw​” (load word). 
Palavras precisam começar em endereços múltiplos de 4, requisito chamado de 
restrição de alinhamento, cada endereço combina o endereço dos 4 bytes dentro da 
palavra. 
 
Para esse controle usamos o Offset que é a constante em relação a posição inicial 
em que a palavra foi inserida. 
 
Offset = 4 * (posição do vetor); 
 
A palavra reservada “​sw​” (store word) cria uma cópia dos dados do registrador para 
a memória. 
Os registradores proporcionam um acesso ao dado mais rápido do que na memória 
e usam menos energia. 
 
Constantes ou operandos imediatos 
As constantes ocorrem com frequência e são incluídas como se fossem operandos, 
o que as tornam mais rápidas e com consumo de energia menor do que sempre ter 
que atribuí-la, além de tornar o caso comum mais veloz. 
 
Números binários 
Como foi dito acima, a arquitetura é em 32 bits, escolhidos entre 0 e 1, são os 
componentes básicos da informação, sendo o bit mais à esquerda o mais 
significativo e a direita o menos significativo. A escala de um número inteiro por 
exemplo vai de (-2³¹ a 2³¹ -1). O MIPS também oferece load byte “lb” que estende o 
bit de sinal de um número e load byte unsigned “lbu” que trata o byte como um 
número sem sinal. 
 
Representação de Instrução no Computador 
Os registradores $s0 a $s7 são mapeados nos registradores de 16 a 23. Já os 
registradores $t0 a $t7 são mapeados nos registradores de 8 a 15. 
1. Formato de instrução: a representação é feita a partir de uma instrução 
composta de campos de números binários 
2. Linguagem de máquina: ​é a representação binária que o sistema 
computacional consegue interpretar e reproduzir. 
3. Código de máquina: ​sequência de instruções em linguagem de máquina. 
 
Em MIPS temostambém operações em relação aos campos, e elas são: 
op​: operação básica da instrução (opcode); 
rs​: o primeiro registrador do operando fonte; 
rt​: o segundo registrador do operando fonte; 
rd​: o registrador que recebe o resultado da operação (destino); 
shamt​: shift amount (quantidade de deslocamento); 
funct​: código de função. Especifica a variante da operação no campo op. 
 
Princípio de Projeto 3: ​Um bom projeto exige bons compromissos. 
É necessário pensar também em como todo este conteúdo deve ser implementado e 
por isso são necessários cuidados como: a necessidade de cada instrução nem 
sempre é a mesma, por isso ter o mesmo formato e tamanho para todas as 
instruções simplifica o hardware, o MIPS define tamanho fixo para instruções, porém 
diferentes tipos, são eles o ​tipo-R ​(registrador) e o ​tipo-I ​(de imediato), utilizado 
pelas instruções imediatas e de transferência de dados. Os formatos são 
identificados pelo campo ​opcode​. 
 
Conflitos 
É difícil conciliar instruções com mesmo tamanho e ter o máximo de registradores 
possível. Qualquer aumento no número de registradores usa pelo menos mais um bit 
em cada campo de registrador do formato de instrução, o que acaba gerando um 
conflito pois quanto menor é o número de registradores, mais rápido fica o ciclo. A 
maior parte dos conjuntos de instruções hoje possui 16 ou 32 registradores de uso 
geral. 
 
Operações Lógicas 
São operações que atuam sobre os campos de bits dentro de uma palavra ou até 
mesmo sobre bits individuais. 
O ​Shift left logical ou “sll” move todos os bits de uma word para a esquerda, o que 
resulta em uma multiplicação exponencial de base 2 pelo número de bits a serem 
deslocados. Ex.: i é o número de bits que serem deslocados, deslocar para esquerda 
resulta em 2^i. Já o ​Shift right logical ou “srl” move todos os bits para a direita. A 
operação ​AND ​compara dois operandos e deixa 1 no resultado somente se os dois 
bits dos registradores forem 1. O operador ​OR deixa 1 no resultado se qualquer um 
dos dois operandos forem 1. O operador ​NOT ​basicamente coloca 1 se o resultado 
for 0 e 0 se for 1. 
Instruções para tomada de decisões 
Temos de desvios condicionais o ​Branch if equal ou “beq” ​que compara dois 
operandos e se forem iguais, é feito o desvio. ​Branch if not equal ou “bne” ​que 
compara os dois operandos e desvia se nao for igual. Além disso temos também o 
“else” para caso a condição não seja satisfeita e ​“exit” ​para sair. Em Assembly 
tem a palavra ​“loop” ​para executar comandos de repetição. Há também como 
controlar caso seja necessário uma variável ser maior que a outra temos o ​Set on 
less than ou “slt” ​que compara dois registradores e atribui 1 a um terceiro 
registrador (booleano) se o primeiro elemento for menor que o segundo, se não 
atribui 0. 
 
Suporte a procedimentos no hardware do computador 
Procedimentos são uma sub-rotina armazenada que realiza uma tarefa baseada nos 
parâmetros que lhe são passados. As etapas são, primeiramente colocar os 
parâmetros onde se possa acessá-los, transferir o controle para o procedimento, 
adquirir os recursos de armazenamento necessários, realizar a tarefa desejada, 
colocar o valor de retorno onde se possa acessá-lo e retornar o controla para o 
ponto de origem. O ​“$ra” ​é um registrador de endereço de retorno, para retornar ao 
ponto de origem. A instrução ​jump-and-link “jal” ​desvia o registrador para um 
endereço e simultaneamente salva o endereço da instrução seguinte (PC + 4) no 
registrador $ra: 
jal Endereço ( para acessar o endereço e o procedimento) 
jr $ra (usado para retornar ao ponto em que estava) 
 
Usando mais registradores 
Todos os registradores necessários na função devem estar “livres” após a execução 
do procedimento chamado, esses valores são organizados em uma pilha, localizada 
no registrador de nº 29 no MIPS é o ​stack pointer, ou $sp​, que indica o endereço 
do topo da pilha, local onde os registradores podem ser restaurados ou onde são 
salvos novos registradores. A pilha “cresce para baixo”, subtrair do valor de $sp 
insere novos elementos na pilha e a soma remove. 
A convenção do software do MIPS separa 18 dos registradores em dois grupos: 
$t0 - $t9 são registradores ​temporários ​que não são preservados pelo 
procedimento chamado. 
$s0 - $s7 são registradores ​salvos que precisam ser preservados em uma 
chamada de procedimento. 
$at​, registrador 1, é reservado para o ​montador. 
$k0 e $k1​, registradores 26 e 27, são reservados para o ​sistema operacional. 
 
Procedimentos aninhados 
São procedimentos que chamam outros, para isso é necessário empilhar todos os 
registradores que precisam ser salvos, o chamador empilha registradores de 
argumento e temporários que precisará após a chamada, em seguida o 
procedimento chamado empilha o $ra e quaisquer $s0 - $s7 usados por ele. $sp é 
ajustado para o topo atual da pilha e por fim, no retorno, os registradores salvos são 
restaurados da memória e o $sp é reajustado. 
 
Como ferramentas também temos um ​ponteiro global “$gp” que é um registrador 
reservado para apontar para a área de armazenamento estático do programa. 
Registro de ativação ​ou ​frame de procedimento é o segmento da pilha contendo 
os registradores salvos e as variáveis locais de um procedimento, arrays e 
estruturas. ​Frame pointer ou “$fp” ​tem a função de apontar para a primeira word 
do registro de ativação de um procedimento. O $fp é ​estável ​em um procedimento 
enquanto o $sp pode ​variar durante a execução. ​Heap ​é o nome do espaço de 
memória reservado para dados dinâmicos como listas encadeadas. 
 
Comunicação com pessoas 
Para que a linguagem de máquina seja traduzida para linguagem humana para que 
ela possa ser interpretada, são utilizadas para o caracteres serem representados, a 
tabela ​ASCII​, onde cada caractere é representado por ​1 byte​. Além disso, o MIPS 
fornece instruções para trazer e salvar bytes da memória: 
lb $t0,0 ($sp) - ​Lê byte da origem 
sb $t0,0 ($sp) - ​Escreve byte no destino 
Códigos em Unicode possuem 16 bits por caractere, para isso o MIPS possui 
instruções para manipular e tratar esses dados de 16 bits, chamados ​halfwords: 
lhu $t0,0 ($sp) -​ Lê halfword da origem 
sh $t0,0 ($sp) - ​Escreve halfword no destino 
 
Paralelismo e Instruções: Sincronização 
Data race: ​Quando acontece dois acessos a memória partindo de threads diferentes 
em direção ao mesmo local, pelo menos um é de escrita e eles ocorrem um após o 
outro. Para isso é necessário formas para sincronizar as instruções para que a 
ordem correta seja executada. 
Operação atômica: ​Consiste na leitura e escrita na memória em uma única 
instrução ininterrupta. 
Multiprocessos e multicores 
Load Vinculado e Store condicional 
O Link vinculado retorna um valor atual de um local de memória, enquanto o store 
condicional guarda um valor e repõe ele caso não seja feita nenhuma atualização. 
 
Falácias e armadilhas 
O que se tem de falácias são: Instruções mais poderosas significam maior 
desempenho, escrever em assembly proporciona maior desempenho, a importância 
da compatibilidade binária comercial significa que os conjuntos de instruções 
bem-sucedidos são mudam. 
 
Todas as afirmativassão falsas. 
 
O que se tem de armadilhas são: Esquecer que os endereços sequenciais de 
palavras em máquinas com endereçamento em bytes não diferem em um. Usar um 
ponteiro para uma variável local fora de sem procedimento pode ocasionar que seu 
ponteiro aponte em posições indesejadas. 
 
 
 
Tradução, compilação e desempenho 
Em C, saimos da linguagem C, e é convertida pelo computador em linguagem 
assembly, é gerado um objeto de linguagem de máquina juntamente com o objeto da 
biblioteca da linguagem de programação, resultando um executável em linguagem 
de máquina e por fim, esse executável será carregado em memória e executado. 
 
 
A seleção de um conjunto de instruções exige equilíbrio entre: 
A quantidade de instruções para executar um programa, quantidade de ciclos de 
clock e a velocidade do clock. 
 
Tempo de CPU = nº de instruções * CPI * tempo de ciclo de clock 
 
Todas as categorias de instruções MIPS está associada a construções que 
aparecem nas linguagens de programação: Instruções aritméticas, transferência de 
dados, desvios condicionais e jumps. 
 
MIPS 1 
# Programa que executa C=A+B 
.data # Define os valores que serão inseridos como tipo dado 
A: .word 7 # A=7 
B: .word 13 #B=13 
C: .word 0 #C=0 (Inicialização) 
 
.text #Diretiva que simboliza o inicio do codigo 
main: la $a0, A #Carrega o endereço de A a ser impresso em $a0 
lw $a0, 0($a0) #Carrega a word que está no endereço(a0+0) 
la $a1, B #copia o endereço do label na memória para o registrador 
lw $a1, 0($a1) #Carrega a word que está no endereço(a1+0) 
addiu $sp, $sp, -4 #Cria uma pilha com um espaço para alocar 
sw $ra, 0($sp) #escreve a word do registrador do retorno na posição 0 da pilha 
jal sum #pula para o endereço de ação para a soma 
lw $ra, 0($sp) #carrega o topo da pilha 
addiu $sp, $sp, 4 # apaga o elemento da pilha 
la $t0, C #copia o endereço da memória para o registrador 
sw $v0, 0($t0) #escreve a word em $v0, no endereço (t0+0) 
jr $ra #retorna a função 
 
# Função que soma $a0 + $a1, colocando resultado em $v0 
sum: addu $v0, $a0, $a1 #soma sem sinal $v0 = C, $a0 = A + $a1 = B 
jr $ra # retorna a função 
 
 
 
 
 
 
 
MIPS 2 
# Programa que executa a somatória do vetor A e coloca o resultado em S 
.data #declaração de dados 
A: .word 1 2 3 4 5 #elementos de A 
T: .word 5 #tamanho de A 
S: .word 0 # Resultante 
 
.text #Implementações 
main: la $a0, T #carrega o endereço do argumento $a0 
lw $a0, 0($a0) #carrega a word que está no endereço $a0 
la $a1, A #carrega o endereço de A, no registrador $a1 
addiu $sp, $sp, -4 #aumenta a pilha em um tamanho de dado 
sw $ra, 0($sp) #escreve a word do registrador do retorno na posição 0 da pilha 
jal sum #pula para o endereço de ação da soma 
lw $ra, 0($sp) #carrega o topo da pilha 
addiu $sp, $sp, 4 # apaga um elemento da pilha 
la $t0, S #copia o endereço de S para o registrador 
sw $v0, 0($t0) #escreve a word em $v0, no endereço (t0+0) 
jr $ra #retorna a função 
 
# Função que faz a somatória dos $a0 elementos do vetor que começa no endereço 
$a1 
# retornando o resultado da somatória em $v0 
sum: lw $v0, 0($a1) #carrega a word que está no $a1 para $v0 
addiu $a0, $a0, -1 #adiciona -1 em $a0 
loop: blez $a0, sai #loop, ramifica se for menor que ou igual a zero 
addiu $a1, $a1, 4 #adiciona 4 no registrador $a1 
lw $t1, 0($a1) #carrega a word que está no $a1 para $t1 
addu $v0, $v0, $t1 #soma $v0 = $v0 + $t1 
addiu $a0, $a0, -1 #adiciona -1 em $a0 
j loop #pula para o loop 
sai: jr $ra #retorno