Docsity
Docsity
Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity

Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium

Guias e Dicas
Guias e Dicas
Venda na Docsity
Venda na Docsity
Docsity I.A.
Docsity I.A.
EntrarCadastre-se

Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity

Encontrar documentos

Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity

Encontra documentos específicos para os exames da tua universidade

Encontra documentos específicos para os exames da tua universidade

Videoaulas

Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade

Quiz

Responda perguntas de provas passadas e avalie sua preparação.

Docsity AINEW

Resuma seus documentos, faça perguntas, converta-os em questionários e mapas conceituais

TCC e ENEM 2026

Estude com provas passadas, TCCs e dicas úteis

Explorar perguntas

Tire suas dúvidas lendo as respostas dadas por outros alunos como você.

Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium

Compartilhe documentos
download point icon20 Pontos

Por cada documento compartilhado

Responda às perguntas
download point icon5 Pontos

por cada resposta enviada (máx. 1 por dia)

Todas as maneiras de obter pontos grátis
Ganhe pontos imediatamente

Escolha um Plano Premium com todos os pontos que precisa

Oportunidades de estudo

Escolha seu próximo programa de estudos

Entre em contato direto com as melhores Universidades do mundo. Pesquise entre milhares de Universidades e parceiros oficiais

Comunidade

Pergunte à comunidade

Peça ajuda à comunidade e tire suas dúvidas relacionadas ao estudo

Guias grátis

Os eBooks que salvam estudantes!

Baixe gratuitamente nossos guias de estudo, métodos para diminuir a ansiedade, dicas de TCC preparadas pelos professores da Docsity

Construção de Processadores e Memórias: Desempenho de Computadores, Instruções e Memória, Notas de aula de Algoritmos e Programação

Universidade Federal de Ouro Preto (UFOP)Algoritmos e Programação

Este documento aborda a construção de processadores e memórias, explicando como calcular o desempenho de um computador, formatos de instruções, ações a serem tomadas dependentes da classe de instrução e a execução de instruções. Além disso, discute-se sobre a organização multi-ciclos, pipeline, execução de instruções do tipo r, acesso à memória e desvio condicional.

Tipologia: Notas de aula

2021

Compartilhado em 04/08/2021

usuário desconhecido
usuário desconhecido 🇧🇷

5 documentos

1 / 36

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
Índice
Aula introdutória..................................................................................................................................2
Aula 01 – Introdução e Pipeline (Parte 01)..........................................................................................2
Aula 02 – Introdução e Pipeline (Parte 2)............................................................................................3
Conceitos Básicos............................................................................................................................3
Aula 03 – Introdução e Pipeline (Parte 03)..........................................................................................5
Aula 04 – Introdução e Pipeline (Parte 04)..........................................................................................7
Aula 05 – Introdução e Pipeline (Parte 05)........................................................................................10
Aula 06 – Introdução e Pipeline (Parte 06)........................................................................................12
Aula 07 – Introdução e Pipeline (Parte 07)........................................................................................15
Organização Multi ciclos...............................................................................................................15
Execução de Instruções..................................................................................................................17
Aula 08 – Introdução e Pipeline (Parte 08)........................................................................................18
Pipelining.......................................................................................................................................18
Aula 09 – Introdução e Pipeline (Parte 09)........................................................................................20
Hazards..........................................................................................................................................20
Aula 10 – Introdução e Pipeline (Parte 10)........................................................................................21
Caminho de dados com Pipeline....................................................................................................21
Aula 11 – Introdução e Pipeline (Parte 11).........................................................................................22
Unidade de controle com Pipeline.................................................................................................22
Detecção e tratamento de conflitos................................................................................................23
Aula 12 – Introdução e Pipeline (Parte 12)........................................................................................24
Aula 13 – FPGA.................................................................................................................................25
Field Programmable Gate Array....................................................................................................25
Application Specific Integrated Circuit (ASIC)............................................................................26
Aula 14 – Linguagens de descrição de hardware (01)........................................................................26
Verilog............................................................................................................................................28
Aula 15 – Linguagens de descrição de hardware (02)........................................................................28
Verilog............................................................................................................................................28
Aula 16 – Linguagens de descrição de hardware (03)........................................................................30
Aula 17 - Paralelismo em Nível de Processadores - (01)..................................................................30
Multiprocessamento.......................................................................................................................30
Aula 18 - Paralelismo em Nível de Processadores - (02)...................................................................31
Aula 19 - Paralelismo em Nível de Processadores - (03)...................................................................33
Em MIPS:......................................................................................................................................33
Associatividade (paralelismo e aritmética computacional)...........................................................34
Aula 20 - Paralelismo em Nível de Processadores - (04)...................................................................34
(Hierarquia de memória) Coerência da Cache...............................................................................35
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24

Pré-visualização parcial do texto

Baixe Construção de Processadores e Memórias: Desempenho de Computadores, Instruções e Memória e outras Notas de aula em PDF para Algoritmos e Programação, somente na Docsity!

Índice

  • Aula introdutória..................................................................................................................................
  • Aula 01 – Introdução e Pipeline (Parte 01)..........................................................................................
  • Aula 02 – Introdução e Pipeline (Parte 2)............................................................................................ - Conceitos Básicos............................................................................................................................
  • Aula 03 – Introdução e Pipeline (Parte 03)..........................................................................................
  • Aula 04 – Introdução e Pipeline (Parte 04)..........................................................................................
  • Aula 05 – Introdução e Pipeline (Parte 05)........................................................................................
  • Aula 06 – Introdução e Pipeline (Parte 06)........................................................................................
  • Aula 07 – Introdução e Pipeline (Parte 07)........................................................................................ - Organização Multi ciclos............................................................................................................... - Execução de Instruções..................................................................................................................
  • Aula 08 – Introdução e Pipeline (Parte 08)........................................................................................ - Pipelining.......................................................................................................................................
  • Aula 09 – Introdução e Pipeline (Parte 09)........................................................................................ - Hazards..........................................................................................................................................
  • Aula 10 – Introdução e Pipeline (Parte 10)........................................................................................ - Caminho de dados com Pipeline....................................................................................................
  • Aula 11 – Introdução e Pipeline (Parte 11)......................................................................................... - Unidade de controle com Pipeline................................................................................................. - Detecção e tratamento de conflitos................................................................................................
  • Aula 12 – Introdução e Pipeline (Parte 12)........................................................................................
  • Aula 13 – FPGA................................................................................................................................. - Field Programmable Gate Array.................................................................................................... - Application Specific Integrated Circuit (ASIC)............................................................................
  • Aula 14 – Linguagens de descrição de hardware (01)........................................................................ - Verilog............................................................................................................................................
  • Aula 15 – Linguagens de descrição de hardware (02)........................................................................ - Verilog............................................................................................................................................
  • Aula 16 – Linguagens de descrição de hardware (03)........................................................................
    • Aula 17 - Paralelismo em Nível de Processadores - (01)..................................................................
      • Multiprocessamento.......................................................................................................................
  • Aula 18 - Paralelismo em Nível de Processadores - (02)...................................................................
  • Aula 19 - Paralelismo em Nível de Processadores - (03)................................................................... - Em MIPS:...................................................................................................................................... - Associatividade (paralelismo e aritmética computacional)...........................................................
  • Aula 20 - Paralelismo em Nível de Processadores - (04)................................................................... - (Hierarquia de memória) Coerência da Cache...............................................................................

Aula introdutória

Vídeo: https://youtu.be/PlLH_UTbUUs

  • Aulas assíncronas;
  • Avaliação: ◦ TP1 – 09/07 (60 pts); ◦ TP2 – 13/08 (25 pts); ◦ Listas (15 pts).
  • Atendimento: ◦ Quarta-feira 13:25 via meet; ◦ Agendar por e-mail;

Aula 01 – Introdução e Pipeline (Parte 01)

Vídeo: https://youtu.be/iqxSFzYVTdI

  • OAC: ◦ Organização : Modo como os componentes internos são estruturados/organizados e como se comportam; ◦ Arquitetura : Modo com que o sistema computacional como um todo está visível aos programas externos, e como esses podem interagir entre si.
  • Classes de computadores: ◦ Computadores pessoais (PC’s): Bom desempenho a baixo custo; ◦ Servidores: Grandes computadores com maior capacidade de processamento. Geralmente com recursos compartilhados e acesso via rede; ◦ Computadores embarcados: maior classe existente. (Smartfones, TV, relógio, notebook, carro…) Combinam desempenho com consumo energético (grande vilão dos embarcados). ◦ O PC é um computador de propósito geral, já os embarcados possuem propósitos específicos.
  • Construção de processadores e memórias: ◦ Processadores e memória em constante evolução; ◦ Redução dos transistores (chaves liga/desliga - 0/1) permitiu a criação dos circuitos integrados (CIs); ▪ Portas lógicas e flip-flops;
  • Implementação básica do MIPS: ◦ Acesso a memória: lw e sw (instruções I-Type); ◦ Aritmética/lógica: add, sub, and, or e slt (instruções R-Type); ◦ Branch e Jump : beq (instrução I-Type), j (instrução J-Type);
  • Primeiros passos em comum: ◦ Envio do valor do PC counter para a memória que contém o código e carregamento da instrução; ▪ PC counter : contador de programa (Registrador que executa instrução por instrução apontando para a próxima, ou seja, é um registrador que contém o endereço de memória da instrução a ser executada); ▪ Apenas um objeto de hardware para realizar essa função; ◦ Leitura dos registradores à partir dos campos descritos na instrução; ▪ lw precisa leitura apenas de um registrador; ▪ add, sub… precisam de dois registradores;
  • Após os dois passos anteriores as ações serão específicas para cada tipo de instrução;
  • Ponto positivo: Simplicidade e Regularidade ; ◦ Ações a serem tomadas dependem da classe de instrução (acesso a memória, aritméticas e lógicas, e desvio).
  • Após execução da instrução, o PC counter é incrementado em 4 bytes (1 word, 32 bits), e a próxima instrução entra na máquina para ser executada. ◦ Uma palavra na arquitetura MIPS tem 32 bits (8 bytes). ◦ Explicação. ◦ O exemplo acima é resumido, sendo na realidade necessário uma unidade de controle para controlar os componentes (Sinais de controle para as unidades); ▪ Controla os multiplexadores (escolhe uma saída baseado nas n entradas);
  • Componentes principais da implementação MIPS: ◦ Combinacionais: Saídas dependem exclusivamente das entradas providas – ULA, MUX…

▪ Ocorre uma combinação para cada entrada; ◦ De estado: Internamente possuem algum mecanismo de armazenamento de estado (valores) – banco de registradores, memória de instrução… ▪ Retenção de estado (a entrada é retida); ◦ AMBOS OBEDECEM O CICLO DE CLOCK;

  • Regime de clock/ Temporização: ◦ Define quando os sinais dos componentes podem ser lidos e quando devem ser escritos; ▪ Provém temporização para que os elementos saibam quando atuar; ▪ Sincronização; ▪ Memória de dados não pode ser lida e escrita ao mesmo tempo, por isso a importância do clock neste caso; - A leitura/escrita simultânea pode gerar dados inconsistentes; ▪ Escritas ao final do ciclo de clock; ▪ Leitura ao início do ciclo de clock; ◦ Ciclo de clock: intervalo de subida entre duas bordas de clock; ◦ Cada registrador possui um sinal de carga que é ativado com lógica direta; ◦ Registradores são disparados pela borda ascendente do relógio (vídeo); ◦ Explicação em vídeo, link anterior; ◦ Em um mesmo ciclo de clock é possível: ▪ Execução de leitura de dado armazenado em um registrador; ▪ Envio do valor através de alguma lógica combinacional previamente criada em hardware; ▪ Escrita do valor no próprio registrador.

Aula 03 – Introdução e Pipeline (Parte 03)

Vídeo: https://youtu.be/384ic6463cM

  • Caminho de dados: ◦ Como construir uma máquina capaz de executar instruções MIPS? ▪ Dados das instruções devem passar por cada componente de hardware relacionado até sua execução completa;

▪ Endereço dos registradores (Reg a ser lido #1, Reg a ser lido #2 eRe a ser escrito); ▪ Explicação (Vídeo); ▪ 5 bits → Quantidades de bits necessários para endereçar o registrador;

  • Existem 32 registradores na linguagem MIPS assembly, portanto, com 5 bits é possível endereçar qualquer 2^5 = 32; ▪ O dado resultante (Dado de escrita) é o dado em si, por isso 32 bits; ▪ EscReg → Sinal de controle; ▪ Controle da ULA → 4 bits para definir o tipo de operação; ▪ Montagem (Vídeo);

Aula 0 4 – Introdução e Pipeline (Parte 04)

Vídeo: https://youtu.be/dkO2qd8ruLg

  • Elementos básicos (continuação): ◦ Elementos necessários para instruções lw e sw (tipo I): ▪ Memória de dados: é necessário de outra memória que não aquela da memória de instruções; - Recebe um endereço de 32 bits e retira um dado (sinal de controle LerMem = 1); - Recebe um endereço de 32 bits e o dado a ser escritp (sinal de controle EscMem = 1) → Não sai nada; ▪ Módulo de extensão de sinal : Transforma 16 bits em 32 bits (Os bits são provenientes do campo Immediate (offset das instruções de acesso a memória); - Endereço base + Immediate; - Só é possível somar dois valores que tem a mesma quantidade de bits; - Em suma, transforma o offset de 16 para 32 bits; ▪ Banco de registradores (já mostrad o); ▪ ULA (já apresentado);

◦ Combinação dos elementos para escrita em memória (RW) (Vídeo) ▪ Essa forma não suporta o LW; ▪ A ULA executa a soma Endereço base + Offset; ◦ Combinação dos elementos para escrita em memória (LW) (Vídeo) ▪ Quando é feito um LW, retira-se da memória de dados e escreve no banco de registradores; ▪ Endereço base é somado com o offset, assim como na etapa de SW; ◦ Elementos necessários para beq (Branch on Equal): ▪ Comparar dois registradores utilizando o bloco ULA (subtração); ▪ Se ocorrer desvio, o endereço do desvio será PC+4+Deslocamento(16bits)

  • O Deslocamento deve ser estendido para 32 bits

Aula 0 5 – Introdução e Pipeline (Parte 0 5 )

Vídeo: https://youtu.be/WrWeIP6rD-g

  • Componente de controle da ULA: ◦ A ULA além das operações básicas aritméticas em instruções do tipo R e também para instruções de acesso a memória e desvio condicional; ◦ ALUControl → Sinal de 4 bits para definir o tipo de operação que a ULA deverá fazer; ◦ Possíveis valores p/ ALUControl: ◦ Para cada uma das opções, executa-se uma função distinta; ◦ É possível gerar os 4 bits de controle da ULA à partir de uma unidade de controle que possui como entrada: ▪ Campo funcion da instrução; ▪ 2 bits adicionais de controle (ALUop) [Enviado pela unidade de controle principal]→ Indica o tipo de operação a ser realizada. Em junção com o funcion é possível dizer pra ULA qual operação será realizada; ▪ A saída da unidade de controle da ULA (não ALUop) é um sinal de 4 bits que controla diretamente a ULA; ◦ Descrição de como é dado o controle do sinal ALUop; ◦ Instruções do tipo I não possuem campo function (LW, RW, beq); ◦ Instruções do tipo R utilizam o campo function, e na ALUop sempre chega 10, a diferença estará no campo function;
  • Esquema de implementação: ◦ A unidade de controle principal (Sinais em azul no esquema): ◦ Sinais booleanos de 1 bit (ou zero ou um) → Explicação em vídeo; ▪ Exceto ALUop que possui 2 bits; ◦ Exceto o PCSrc, a unidade de controle principal é a responsável por controlar todos os sinais. ◦ O valor da saída ‘zero’ da ULA é utilizado para auxiliar na seleção do valor de PCSrc; ◦ A unidade de controle principal pode ser representada como um único componente capaz de controlar todos os sinais da máquina. ◦ O valor de cada sinal de controle depende exclusivamente do valor contido no campo ‘opcode’ (bist 26 a 31 → Intruções R-type, I-type e J-type) ▪ “É assim que a unidade de controle sabe quando acionar os bits” ◦ Explicação em desenho (Vídeo);
  • Porta AND ( Vídeo ) : ◦ Funciona como auxiliar para o beq, atuando sobre um multiplexador que retroalimenta o PC counter. Sendo assim, o MUX seleciona entre o valor do PC+4, ou o valor do endereço alvo do desvio condicional (beq). ▪ Sinal de desvio condicional vinda do controle principal a 1 (branch) + ‘zero’ da ULA a 1 → Significa que a condicional foi satisfeita, então o MUX indica o endereço com o shift left. ▪ Se não for instrução de branch, ou caso o ‘zero’ da ULA seja zero, então é direcionado o PC+4;
  • Os bits de 0-5 representa o campo funcion das instruções do tipo R.

▪ O sinal ‘zero’ da ULA é utilizado para se decidir qual será o novo valor a ser armazenado dentro do PC.

  • Sumarização das tabelas anteriores;
  • Implementação das instruções Jumps (Desvios incondicionais ): ◦ Não dependem de condição alguma para serem executados; ◦ O cálculo do novo valor de PC é feito de forma incondicional; ◦ Instruções do tipo J: 6 bits de opcode (31-26) e 26 bits de endereço (25-0); ▪ O formato de endereço de MIPS são 32 bits, porém a instrução J separa apenas 26 bits para endereço. ▪ Para compor os 32 bits, é necessário: - 4 bits mais significativos do PC+4 → (31-28) + (25-0) + 2 bits (00) ‘shift left’; ◦ Para o Jump, é necessário mais um MUX para seleciona de forma correta o valor de PC; ◦ Para isso, é necessário um novo sinal de controle → Jump
  • As execuções não são instantâneas, e a junção dos atrasos totais gera o tempo total. (Vídeo) ◦ A instrução ‘mais barata’ é o beq; ◦ Instruções de acesso à memória são as mais caras; ◦ O período do clock deve ser de 12ns (1/12n =~ 83MHz)
  • Problema : Recursos de hardware não podem ser reaproveitados ( Desperdício ): ◦ Duas memórias (Instrução e dados); ◦ ULA; ◦ Dois somadores;
  • A implementação atual (máquina monociclo) não é utilizada pois é ineficiente (limitação da frequência), o ciclo de clock precisa ser grande o suficiente para acomodar a instrução mais demorada ( lw ), portanto é necessário organizar multi ciclos para permitir o PIPELINE ;
  • Exercícios :

◦ Todos os registradores (exceto o IR) armazenam dados somente entre as bordas de relógio adjacente e portanto, não necessitam sinal de escrita somente sinal de clock;

  • Barreiras temporais: ◦ Os registradores são barreiras temporais; ◦ PC; ◦ Registrador de instrução; ◦ Registrador de dados da memória; ◦ A e B; ◦ Saída da ULA;
  • Exemplo de divisão de etapas
  • Os sinais de controle (Vídeo) ◦ Mesmo controle da ULA usado na versão monociclo (ULAOp)
  • Características do bloco operativo Multiciclos: ◦ Acréscimo de recursos para suportar jump e beq: ◦ Três possíveis fontes para o valor de PC : ▪ PC+4 → Sempre será armazenado no PC; ▪ Conteúdo do ULASaída →Este registrador armazena o endereço-alvo do desvio condicional, após ter sido calculado pela ULA (beq) ▪ 26 bits menos significativos do IR deslocados de 2 bits (jump)

Execução de Instruções

  1. Busca da instrução (e incremento PC Counter). Obs.: Ocorrem em paralelo
    1. RI ← Mem[PC]
    2. PC = PC+
  2. Decodificação (Geração do OPCODE) e Leitura de RS e RT
    1. A ← Reg[RI[25-21]] B ← Reg[RI[20-16]] ULASaída ← PC + (Extensão do sinal (RI[15-0] << 2) (Exemplo)
  3. Execução da instrução
    • Referência à memória: ULASaída ← A + extensão(RI[15-0)
    • Tipo R ULASaída = A op B
    • Desvio condicional Se (A=B) então PC ← ULASaída Usar a ULA para fazer A-B, porém sem escrever em ULASaída;
    • Desvio incondicional PC ← PC[31-28] || (RI[25-0] << 2)
  4. Final da Execução de sw e Tipo R ◦ lw: RDM = Mem[ULASaída] ◦ Sw: Mem[ULASaída] = B ◦ Tipo R: Reg[RI[15-11]] = ULASaída

◦ As etapas descrevem estágios do pipeline ;

  • Exemplo de ganho de tempo na execução do MIPS (vídeo);
  • Se os estágios de um pipeline forem balanceados, então: ◦ Valor de ganho teórico; ◦ Dificilmente em uma máquina real se atinge o valor de ganho calculado (quanto mais instruções, mais se aproxima, porém não chega); ◦ Costuma-se dizer que o ganho máximo teórico de um pipeline é igual ao número de estágios do mesmo;
  • Motivos pelo qual o ganho teórico não é atingido: ◦ Os estágios de um pipeline não são perfeitamente balanceados; ◦ Existe um overhead referente ao preenchimento do pipeline (‘até a água chegar do outro lado, é preciso encher o encanamento’); ▪ O tempo entre instruções é mais importante do que o tempo total (quando se analisa uma máquina com pipeline, a vazão é mais importante do que o tempo para executar cada instrução);
  • Exemplo de cálculo de tempo de execução com 1003 instruções (Vídeo);
  • O pipeline aumenta o desempenho por meio da vazão das instruções (e não através do aumento de velocidade no processamento de cada instrução);
  • Facilidade de implementação do pipeline em MIPS (vs. x86): ◦ Todas as intruções possuem o mesmo tamanho (32bits) → Facilidade no carregamento e decodificação das instruções. (A padronização das instruções simplifica o projeto de hardware em MIPS – Instruções de mesmo tamanho);

◦ Poucos formatos de instrução: permite carregar registradores enquanto instrução ainda está sendo decodificada; ◦ Os operandos de memória aparecem apenas nas instruções de load/store: Estágio já existente pode ser utilizado para o calculo endereço (Se existe somente uma classe de instruções que trabalham com acesso à memória, é possível simplificar o projeto do processador); ◦ Operandos estão alinhados na memória: Com somente um acesso, os dados são lidos e carregados. ▪ Tudo alinhado (32bits)

Aula 0 9 – Introdução e Pipeline (Parte 0 9 )

Vídeo: https://youtu.be/WhPyFTNAo5A

Hazards

  • Durante o pipeline, determinadas situações impedem que a próxima instrução comece a executar já no próximo ciclo de clock → Eventos conhecidos como Hazards;
  • Hazard Estrutual: ◦ O hardware não suporta a combinação de instruções a serem executadas em um mesmo ciclo de clock; ◦ Na analogia da lavanderia é como se lavagem e secagem representassem um único estágio; ◦ Por exemplo: sem dois blocos de memória, pode ser que o pipeline em MIPS seja impossível; ▪ Não da para fazer duas leituras ao mesmo tempo (uma para instrução e outra para dados)
  • Hazard de dados: ◦ Ocorre quando o pipeline precisa parar para aguardar que um estágio anterior seja completado; ◦ Aparecem a partir da dependência de uma instrução atual por uma anterior ainda não finalizada; ▪ O registrador $s0 é utilizado nas duas instruções. No add, $s0 é registrador destino. No sub, $s0 é utilizado como fonte. ▪ Somente no 5º passo (escrita nos registradores, é que o dado estaria pronto);