Sistemas Computacionais

💻 Sistemas Computacionais — Notas de Aula

Organizacao de Computadores | Interface HW/SW | E/S | Sistemas Operacionais

Módulo 1 — Organização de Computadores

Unidade 1 · Processador e Execução de Instruções

Um computador segue a Arquitetura de Von Neumann: CPU, memória, E/S e barramento. Programa e dados ficam na mesma memória.

Componentes da CPU

ULA — opera dados (+, -, AND, OR…)
UC — busca, decodifica e executa
Registradores — memória interna ultra-rápida

Registradores Importantes

PC — endereço da próxima instrução
IR — instrução atual em execução
MAR — endereço de memória
MDR — dado lido/escrito na memória
ACC — resultado da ULA

Ciclo Fetch-Decode-Execute

1. FETCH PC → MAR → Memória → MDR → IR (busca instrução) 2. DECODE UC identifica o opcode do IR (entende a instrução) 3. EXECUTE UC aciona ULA / registradores (executa) 4. PC = PC+1 aponta para próxima instrução (repete infinitamente)

Exemplo — ADD R1, R2

1. Fetch: busca instrução no endereço do PC.
2. Decode: UC identifica ADD, operandos R1 e R2.
3. Execute: ULA soma R1+R2, resultado em R1.
4. PC incrementa para próxima instrução.

⚠ Pipeline

Executa várias instruções em paralelo, cada uma em fase diferente. Aumenta throughput mas não reduz a latência de uma instrução individual. Problema: dependência entre instruções causa bolhas (stall).

⚠ RISC vs CISC

RISC (ARM, MIPS): instruções simples, tamanho fixo, 1 ciclo. Fácil de fazer pipeline. CISC (x86): instruções complexas, tamanho variável, mais próximas de alto nível. Mais poderoso por instrução.

Unidade 2 · Hierarquia de Memórias

Nível	Tipo	Velocidade	Tamanho	Custo
Registradores	Flip-flops na CPU	~0,3 ns	Bytes	Altíssimo
Cache L1/L2/L3	SRAM	1–10 ns	KB–MB	Alto
RAM Principal	DRAM	~60 ns	GB	Médio
SSD / HD	Flash / Magnético	μs – ms	TB	Baixo
Fita / Nuvem	Magnético / Rede	Segundos	PB	Muito baixo

Memória Cache

Localidade Temporal

Dado usado recentemente tende a ser usado de novo em breve. Ex: variável i de um loop.

Localidade Espacial

Dados próximos ao que foi acessado tendem a ser acessados logo. Ex: elementos consecutivos de um array.

⚠ Hit vs Miss

Cache Hit: dado encontrado na cache → rápido. Cache Miss: dado não está → busca na RAM e traz para cache. Taxa de hit ≈ 95% em bons programas.

Memória Virtual

Permite usar mais memória do que a RAM física disponível, usando o disco como extensão. O SO mapeia endereços virtuais em físicos via tabela de páginas.

⚠ Page Fault

Página acessada não está na RAM → SO interrompe o processo, carrega do disco e retoma. Excessos de page fault = thrashing — sistema trava trocando páginas em vez de processar.

Exercícios Resolvidos

Exercício 1: Qual é o papel do PC (Program Counter)?

→ Guardar o endereço da próxima instrução a ser executada.

Após cada fetch o PC é incrementado. Em desvios (if/for), o PC recebe o endereço do salto destino.

Exercício 2: Por que a cache funciona bem na prática?

→ Programas exibem localidade temporal e espacial — acessam repetidamente os mesmos dados e dados próximos.

Loops acessam a mesma variável várias vezes (temporal). Arrays são percorridos sequencialmente (espacial). Isso garante alta taxa de hit.

Módulo 2 — Interface Hardware/Software

Unidade 1 · ISA e Linguagem de Montagem (Assembly)

O ISA (Instruction Set Architecture) é a interface entre hardware e software — define instruções disponíveis, registradores e modos de endereçamento.

Tipo de Instrução	O que faz	Exemplo
Aritmética/Lógica	Operações na ULA	ADD R1, R2, R3 → R1 = R2+R3
Transferência	Move dados entre registradores e memória	LOAD R1, 100 → R1 = MEM[100]
Desvio (Branch)	Altera fluxo de execução	BEQ R1, R2, label
Comparação	Compara valores, seta flags	CMP R1, R2
E/S	Comunica com dispositivos	IN / OUT porta, reg

Modos de Endereçamento

Modo	Operando obtido	Exemplo
Imediato	Valor está na própria instrução	ADD R1, #5 → R1 = R1+5
Direto	Endereço de memória na instrução	LOAD R1, 200 → R1=MEM[200]
Indireto por Reg.	Registrador guarda o endereço	LOAD R1, (R2) → MEM[R2]
Indexado	Base + deslocamento	LOAD R1, 4(R2) → MEM[R2+4]

; Exemplo Assembly x86 — soma de dois números mov eax, [a] ; carrega 'a' no registrador EAX add eax, [b] ; EAX = EAX + b mov [result], eax ; salva resultado na memória ; if (a > b) em Assembly cmp eax, ebx ; compara a e b, seta flags jg maior ; jump if greater → salta para 'maior' ; bloco else aqui maior: ; bloco then aqui

⚠ Importante

Assembly é dependente de arquitetura — código x86 não roda em ARM sem recompilar. C e Java abstraem isso: o compilador/JVM gera o código correto para cada plataforma.

Unidade 2 · Tradução de Alto Nível para Máquina

Código-fonte (.c / .java) ↓ Compilador Assembly / Bytecode ↓ Montador (Assembler) Código de Máquina (binário) ↓ Linker Executável final

Ferramenta	Função	Entrada → Saída
Compilador	Traduz código-fonte para assembly/objeto	.c → .s / .o
Montador	Converte assembly para código de máquina	.s → .o
Linker	Une módulos e bibliotecas	.o → executável
Loader	Carrega executável na memória e inicia	executável → processo
Interpretador	Executa linha a linha sem compilar antes	.py → executa direto

Exercícios Resolvidos

Exercício 3: Qual a diferença entre compilador e interpretador?

→ Compilador traduz tudo antes (mais rápido na execução). Interpretador traduz e executa linha a linha (mais flexível, mais lento).

C é compilado. Python é interpretado. Java é híbrido: compila para bytecode e a JVM interpreta/JIT-compila.

Exercício 4: No modo imediato, onde está o operando?

→ Embutido na própria instrução — não precisa acessar a memória.

É o modo mais rápido. A limitação é o tamanho do valor (cabe em poucos bits da instrução). Ex: ADD R1, #5 — o 5 vem direto da instrução.

Módulo 3 — Entrada e Saída e Arquiteturas Atuais

Unidade 1 · Dispositivos e Operações de E/S

Técnica E/S	Como funciona	CPU bloqueada?	Uso
Polling (E/S Programada)	CPU fica em loop verificando se terminou	Sim — busy-wait	Sistemas embarcados simples
Interrupção	Dispositivo avisa CPU via IRQ ao terminar	Não	Teclado, mouse, rede
DMA	Controlador DMA transfere sem envolver a CPU	Quase não	Disco, placa de vídeo, áudio

Exemplo — Interrupção de Teclado

1. Tecla pressionada → controlador gera IRQ.
2. CPU termina instrução atual e salva contexto.
3. Executa ISR (Interrupt Service Routine) — lê o dado.
4. Restaura contexto e continua o programa anterior.

Exemplo — DMA para leitura de disco

1. CPU configura DMA: destino na RAM, quantidade, endereço no disco.
2. DMA assume o barramento e transfere diretamente para RAM.
3. Ao terminar, DMA gera interrupção para avisar a CPU.
4. CPU não ficou bloqueada durante a transferência!

⚠ Barramento (Bus)

Dados: transporta os dados. Endereços: indica onde ler/escrever. Controle: sinais de leitura, escrita, interrupção. Largura do barramento de endereços define o espaço máximo endereçável (32 bits → 4 GB).

Unidade 2 · Arquiteturas de Computadores Atuais

Arquitetura	Tipo	Exemplos	Uso principal
x86-64	CISC	Intel Core, AMD Ryzen	Desktops, servidores
ARM	RISC	Apple M1/M2, Snapdragon	Mobile, notebooks
RISC-V	RISC open-source	SiFive, chips IoT	Pesquisa, IoT
GPU	Milhares de núcleos simples	NVIDIA, AMD	IA, gráficos, computação paralela

Classificação de Flynn

SISD: 1 instrução, 1 dado (clássico)
SIMD: 1 instrução, múltiplos dados (GPU, AVX)
MIMD: múltiplas instruções, múltiplos dados (multicore)

Lei de Amdahl

Speedup máximo é limitado pela fração serial do programa. Se 20% é serial → speedup máximo = 5×, independente de quantos núcleos adicionar.

Exercícios Resolvidos

Exercício 5: Por que DMA é preferível ao polling para grandes transferências?

→ DMA libera a CPU para outras tarefas. Polling desperdiça 100% da CPU em busy-wait.

1GB de disco com polling: CPU fica presa em loop por segundos. Com DMA: executa outros processos e recebe interrupção ao final.

Exercício 6: Por que ARM domina smartphones e x86 domina desktops?

→ ARM é mais eficiente energeticamente (bateria). x86 tem maior desempenho bruto com energia ilimitada.

RISC executa instruções simples com menos transistores e calor. CISC faz mais por ciclo mas consome mais energia — inviável em mobile.

Módulo 4 — Sistemas Operacionais

Unidade 1 · Gerência de Processos

Processo

Programa em execução com espaço de memória próprio e isolado. Troca de contexto entre processos é custosa.

Thread

Linha de execução dentro de um processo. Threads compartilham memória do processo. Troca de contexto é mais leve.

Estados de um Processo

Novo → Pronto → Executando ⇌ Bloqueado → Pronto → ... → Terminado Novo: criado, aguardando admissão pelo SO Pronto: na fila, esperando CPU Executando: usando a CPU (1 por núcleo por vez) Bloqueado: aguardando E/S ou evento (libera a CPU) Terminado: execução encerrada

Algoritmos de Escalonamento

Algoritmo	Como funciona	Preemptivo?	Problema
FCFS	Ordem de chegada	Não	Convoy effect: processo longo bloqueia todos
SJF	Menor burst de CPU primeiro	Depende	Starvation de processos longos
Round Robin	Cada processo ganha um quantum, depois vai ao fim da fila	Sim	Overhead se quantum muito pequeno
Prioridade	Maior prioridade executa primeiro	Depende	Starvation de baixa prioridade

Exemplo — Round Robin quantum=4ms

P1(burst=8), P2(burst=4), P3(burst=6).
Ordem: P1(4)→P2(4)→P3(4)→P1(4)→P3(2). Nenhum processo fica preso esperando outro terminar.

Unidade 2 · Gerência de Memória

Técnica	Como funciona	Problema
Partição fixa	RAM em blocos fixos — processo ocupa um bloco	Fragmentação interna
Partição variável	Blocos do tamanho exato do processo	Fragmentação externa
Paginação	Processo em páginas, RAM em frames. Tabela de páginas mapeia.	Overhead da tabela
Segmentação	Processo em segmentos lógicos (código, dados, pilha)	Fragmentação externa

⚠ Fragmentação

Interna: espaço desperdiçado dentro do bloco alocado (bloco 4KB para processo 3KB → 1KB perdido). Externa: espaço livre espalhado em fragmentos não contíguos — soma seria suficiente, mas não serve.

Exercícios Resolvidos

Exercício 7: Qual a diferença entre processo e thread?

→ Processo tem memória própria e isolada. Threads compartilham a memória do processo pai.

Thread é mais leve — ideal para paralelismo dentro do mesmo programa. Ex: servidor web cria uma thread por requisição, não um processo novo.

Exercício 8: Por que Round Robin é mais justo que FCFS?

→ Divide CPU igualmente com quantum. FCFS pode deixar processos curtos esperando um processo longo terminar.

Com quantum=100ms, cada processo tem no máximo 100ms por vez. No FCFS, P1 com burst de 10s trava P2 e P3 inteiros.

📝 Cola de Prova — Sistemas Computacionais

Hierarquia de Memória

Registradores → Cache L1 → L2 → L3 → RAM → SSD → HD → Fita ~0,3ns ~1ns ~5ns ~10ns ~60ns μs ms

Ciclo de Instrução

PC → MAR → Memória → MDR → IR → UC decodifica → ULA executa → PC+1

Técnicas de E/S

Técnica	CPU bloqueada?	Uso ideal
Polling	Sim — busy-wait	Embarcados simples
Interrupção	Não	Teclado, mouse, rede
DMA	Quase não	Disco, vídeo, áudio

Escalonamento

Algoritmo	Preemptivo?	Problema
FCFS	Não	Convoy effect
SJF	Depende	Starvation
Round Robin	Sim	Overhead de quantum pequeno
Prioridade	Depende	Starvation de baixa prioridade

⭐ Regras de Ouro

Regra

PC = endereço da próxima instrução. IR = instrução atual.

Regra

Cache funciona por localidade temporal e espacial

Regra

Page fault = página não está na RAM. Thrashing = page faults excessivos

Regra

DMA transfere dados sem envolver a CPU — melhor para grandes volumes

Regra

Fragmentação interna = dentro do bloco. Externa = entre blocos espalhados

Regra

RISC = simples, eficiente (ARM mobile). CISC = complexo, poderoso (x86 desktop)

Regra

Thread compartilha memória. Processo tem memória isolada