aula 1

curso/aula-01.org

@@ -0,0 +1,302 @@
+* Aula 1 – Arquitetura de Computadores
+
+** Objetivos
+
+- Compreender os principais componentes de um computador sob o modelo de von Neumann.
+- Reconhecer os registradores da arquitetura x86_64.
+- Entender a relação entre hardware e código Assembly.
+- Executar o primeiro programa Assembly com uma chamada de sistema.
+
+** Modelo de von Neumann
+
+Um computador possui:
+  
+- Unidade de processamento (ALU + Controladora)
+- Memória (armazenamento de instruções e dados)
+- Dispositivos de entrada/saída
+
+O modelo de Von Neumann é uma arquitetura de computadores em que a unidade
+central de processamento (CPU) e a memória compartilham um único espaço de
+armazenamento, tanto para dados quanto para instruções de programa. Isso
+significa que o processador acessa a memória de forma sequencial para buscar
+dados e instruções, utilizando um único barramento para ambas as operações.
+
+No modelo de Von Neumann:
+  
+- Instruções e dados compartilham o mesmo espaço de memória.
+- A CPU executa o ciclo: busca → decodifica → executa.
+
+Como era antes:
+
+- Instruções e dados armazenados em memórias separadas.
+- A CPU executa o ciclo: busca → decodifica → executa, mas pode realizar a busca
+  de dados e instruções em paralelo.
+
+*** Influência nas arquiteturas modernas
+
+O modelo de Von Neumann influenciou profundamente as arquiteturas modernas de
+computadores, estabelecendo a base para a maioria dos designs de sistemas
+computacionais atuais. Algumas das principais influências incluem:
+
+- Memória unificada ::
+
+  A ideia de compartilhar a mesma memória para dados e instruções se manteve
+  como o padrão em muitas arquiteturas modernas, simplificando o design dos
+  sistemas, embora existam variações: como a memória cache, que separa dados e
+  instruções em níveis mais próximos ao processador.
+
+- Ciclo de busca, decodificação e execução ::
+
+  O modelo de Von Neumann introduziu o ciclo básico de execução de instruções,
+  que ainda é fundamental em CPUs modernas. As arquiteturas atuais, como x86 e
+  ARM, seguem esse ciclo de maneira semelhante, embora com otimizações como a
+  /pipelining/, onde múltiplas fases do ciclo podem ser realizadas em paralelo.
+
+- Programação e flexibilidade ::
+
+  O modelo permite que os programas sejam tratados como dados, o que possibilita
+  a criação de sistemas que podem ser facilmente modificados e adaptados. Isso
+  contribui para o desenvolvimento de linguagens de programação de alto nível,
+  sistemas operacionais e aplicativos dinâmicos.
+
+- Simplicidade e custo ::
+
+  O modelo de Von Neumann simplificou o design de computadores ao integrar a
+  memória de instruções e dados. Isso contribuiu para a redução de custos de
+  hardware, tornando os sistemas mais acessíveis e facilitando o desenvolvimento
+  de sistemas comerciais e pessoais.
+
+#+begin_quote
+*Nota:* A /pipelining/ (do conceito de /"linha de montagem"/) é uma técnica de
+ execução paralela em que múltiplas instruções são processadas simultaneamente
+ em diferentes /estágios/ do ciclo de execução para aumentar o desempenho da
+ CPU. Isso difere do conceito geral de /paralelismo/, onde /tarefas completas/, e
+ não estágios do processamento, são executadas simultaneamente.
+#+end_quote
+
+*** Gargalo de Von Neumann
+
+O gargalo de Von Neumann é uma limitação de desempenho causada pelo fato de que
+a CPU e a memória compartilham o mesmo barramento para acessar instruções e
+dados.
+
+Isso significa que:
+
+- A CPU não pode buscar uma instrução e acessar dados ao mesmo tempo.
+- O tempo de espera entre operações aumenta, especialmente em programas que
+  exigem muitos acessos à memória.
+- A largura de banda do barramento se torna um fator crítico para o desempenho.
+
+Esse gargalo levou ao desenvolvimento de soluções como:
+
+- Memória cache (para reduzir acessos à RAM)
+- Execução paralela e /pipelines/
+- Arquiteturas modificadas (como o modelo Harvard modificado)
+
+#+begin_quote
+*Nota:* A /arquitetura Harvard modificada/ é uma variação do modelo de Von Neumann
+que usa memórias separadas internamente (como em caches) para dados e instruções,
+mantendo um espaço de memória unificado do ponto de vista do programador.
+#+end_quote
+
+** Arquiteturas x86
+
+A arquitetura x86 é uma família de conjuntos de instruções (ISA – /Instruction
+Set Architecture/) baseada no modelo de Von Neumann e desenvolvida originalmente
+pela Intel a partir do processador 8086.
+
+Assim como no modelo de Von Neumann:
+
+- Dados e instruções compartilham o mesmo espaço de memória.
+- A CPU segue o ciclo: busca → decodifica → executa.
+
+#+begin_quote
+*Nota:* A transição da arquitetura x86 de 32 para 64 bits foi liderada pela AMD
+com a criação da AMD64 em 2003. Essa extensão manteve compatibilidade com o
+conjunto de instruções x86 original (IA-32), mas adicionou registradores de 64
+bits e suporte a endereçamento ampliado. Posteriormente, a Intel adotou essa
+mesma arquitetura sob o nome Intel 64 (anteriormente chamada EM64T), e o termo
+x86-64 passou a ser usado de forma genérica para se referir à arquitetura compatível
+com AMD64. Assim, AMD64 é a origem técnica da arquitetura x86 de 64 bits utilizada
+na maioria dos sistemas modernos.
+#+end_quote
+
+*** Características
+
+- ISA complexa (CISC – /Complex Instruction Set Computing/), com centenas de
+  instruções e modos de endereçamento.
+- Suporte a múltiplos tamanhos de palavra (16, 32 e 64 bits nas versões modernas).
+- Registradores de uso geral (AX, BX, CX, etc.) e segmentados (CS, DS, SS...,
+  não utilizados no Linux), herdados de versões mais antigas.
+- Ampla compatibilidade com versões anteriores (retrocompatibilidade).
+- Utilizada em desktops, laptops e servidores, sendo a base da maioria dos PCs atuais.
+
+#+begin_quote
+*Nota:* Embora a arquitetura x86 inclua registradores segmentados (como CS, DS, ES, SS),
+o Linux não faz uso da segmentação de memória no modo protegido. Em vez disso, ele
+utiliza o chamado /endereçamento plano/, tratando toda a memória como um único espaço
+contínuo. A segmentação é mantida apenas em um nível mínimo para atender exigências
+da arquitetura (como troca de contexto e proteção básica), mas a segmentação lógica,
+como era usada no MS-DOS, é totalmente evitada.
+#+end_quote
+
+*** Otimizações em relação ao modelo de Von Neumann
+
+A arquitetura x86 é uma evolução prática do modelo de Von Neumann, com
+otimizações como:
+
+- Uso extensivo de memória cache.
+- Execução fora de ordem (/out-of-order execution/).
+- /Pipelines/ e paralelismo interno.
+
+*** Comparativo com outras arquiteturas
+
+Todas as arquiteturas modernas seguem, em maior ou menor grau, os princípios
+do modelo de Von Neumann. No entanto, diferem na forma como organizam e executam
+instruções. Veja o comparativo:
+
+*x86 (CISC – /Complex Instruction Set Computing/):*
+
+- Conjunto de instruções extenso e complexo.
+- Instruções de vários tamanhos e com múltiplos modos de endereçamento.
+- Maior consumo de energia, mas com alta compatibilidade e maior desempenho bruto.
+- Retrocompatibilidade com código legado.
+- Comum em PCs, laptops e servidores.
+
+*ARM (RISC – /Reduced Instruction Set Computing/)*
+
+- Conjunto de instruções reduzido e regular.
+- Foco em simplicidade, baixa energia e eficiência.
+- Desempenho por watt muito superior ao x86.
+- Predominante em dispositivos móveis (smartphones, tablets) e embarcados.
+- ARM64 (AArch64) é a versão de 64 bits moderna.
+
+*RISC-V (RISC e /open source/):*
+
+- ISA aberta, modular e extensível.
+- Sem royalties: qualquer um pode implementar.
+- Design limpo e simples, adequado para pesquisa, educação e sistemas customizados.
+- Crescimento em sistemas embarcados e processadores personalizados.
+
+*Resumo comparativo:*
+
+| Arquitetura | Tipo | Complexidade | Consumo | Uso comum                     |
+|-------------+------+--------------+---------+-------------------------------|
+| x86         | CISC | Alta         | Alto    | PCs, laptops, servidores      |
+| ARM         | RISC | Média        | Baixo   | Celulares, IoT, Apple M1+     |
+| RISC-V      | RISC | Baixa        | Baixo   | Pesquisa, sistemas embarcados |
+
+** Componentes de uma CPU x86_64
+
+- Unidade de Controle (/Control Unit/ - CU) ::
+
+  Gerencia o fluxo de dados e as instruções dentro da CPU, coordenando as operações
+  de execução.
+
+- Unidade Lógica e Aritmética (ALU – /Arithmetic and Logic Unit/) ::
+
+  Responsável pela execução de operações aritméticas (soma, subtração, etc.) e
+  lógicas (AND, OR, NOT, etc.).
+
+- Registradores de uso geral ::
+
+  Utilizados para armazenar dados temporários durante a execução de instruções
+  (ex.: RAX, RBX, RCX, etc.).
+
+- Registradores de propósito específico ::
+
+  Como o ponteiro de pilha (RSP), ponteiro de instrução (RIP) e flags (como EFLAGS).
+
+- Registradores de segmentos ::
+
+  Armazenam endereços de segmentos de memória para código (CS), dados (DS) e pilha
+  (SS), além dos registradores de segmentos adicionais para dados (ES, FS e GS).
+
+- Cache ::
+
+  Memória de acesso ultrarrápido usada para armazenar dados frequentemente
+  acessados, visando reduzir o tempo de acesso à memória principal. Normalmente
+  dividida em L1, L2 e, em algumas CPUs, L3.
+
+- Barramentos ::
+
+  Conjunto de trilhas de comunicação que transportam dados entre a CPU e outros
+  componentes, como a memória, dispositivos de entrada/saída e outros núcleos.
+
+- Unidade de Execução (/Execution Unit/ – EU) ::
+
+  Responsável por executar as instruções. Em CPUs modernas, pode haver múltiplas
+  unidades de execução para executar diferentes tipos de operações em paralelo.
+
+- Decodificador de Instruções ::
+
+  Interpreta as instruções da linguagem de máquina (bytecode) e as converte para
+  operações que podem ser executadas pela ALU ou outras unidades de execução.
+
+- Unidade de carga e armazenamento (/Load-Store Unit/ - LSU) ::
+
+  Controla o carregamento e armazenamento de dados na memória, realizando
+  operações de leitura e escrita.
+
+- Unidade de Endereçamento (/Address Generation Unit/ - AGU) ::
+
+  Calcula endereços de memória, especialmente no contexto de operações de acesso
+  à memória e cálculo de ponteiros.
+
+- Controlador de Interrupções (/Interrupt Controller/) ::
+
+  Responsável por lidar com interrupções externas e internas, gerenciando a
+  prioridade e o tratamento adequado das interrupções no sistema.
+
+** Principais registradores e seus propósitos (64 bits)
+
+- =RAX=: acumulador/propósito geral
+- =RBX=: base/propósito geral
+- =RCX=: contador/propósito geral
+- =RDX=: dados/propósito geral
+- =RSI=: índice de origem
+- =RDI=: índice de destino
+- =RSP=: ponteiro da pilha
+- =RBP=: base da pilha
+- =RIP=: ponteiro de instrução
+- =RFLAGS=: sinalizações diversas
+
+A arquitetura x86_64 ainda inclui oito registradores de propósito geral, de =R8=
+a =R15=.
+
+** Primeiro exemplo em Assembly x86_64
+
+#+begin_src asm
+; Retorna 42 como estado de término
+
+section .text
+    global _start
+
+_start:
+    mov     rax, 60        ; syscall: exit
+    mov     rdi, 42        ; código de saída
+    syscall
+#+end_src
+
+*** Compilação e execução (no terminal)
+
+#+begin_example
+:~$ nasm -f elf64 -o exit42.o exit42.asm
+:~$ ld -o exit42 exit42.o
+:~$ ./exit42
+:~$ echo $?
+42
+#+end_example
+
+** Exercícios sugeridos
+
+1. Modifique o programa Assembly para retornar "sucesso".
+2. Desmonte (=objdump -d=) os binários gerados e compare os códigos de máquina.
+3. Use =strace ./exit42= para verificar a chamada de sistema realizada.
+
+** Referências
+
+- [[https://namazso.github.io/x86/][Intel® 64 and IA-32 Instruction Set Reference]]
+- [[https://wiki.osdev.org/CPU_Registers_x86-64][OS Dev: CPU Registers x86-64]]
+- [[https://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/][Linux System Call Table for x86 64]]
+- =man 2 exit=