1. Explique a diferença entre \mathrm{E} / \mathrm{S} programada, \mathrm{E} / \mathrm{S} por interrupção e DMA.

Passo 1

O enunciado pede que eu explique a diferença entre três maneiras de fazer entrada/saída: \mathrm{E}/\mathrm{S} programada, \mathrm{E}/\mathrm{S} por interrupção e \mathrm{DMA}.
Informações que tenho (implícitas no enunciado): cada método descreve como um periférico transfere dados entre si e a memória/CPU; é importante comparar quem faz o trabalho (CPU, periférico, controlador), quando isso acontece (polling contínuo, evento assíncrono, transferências diretas), e quais são vantagens e desvantagens (uso de \mathrm{CPU}, latência, throughput, complexidade).

Passo 2

Conceito básico de \mathrm{E}/\mathrm{S} que preciso dominar antes de diferenciar métodos:
  • \mathrm{E}/\mathrm{S} é a operação de mover dados entre um periférico (teclado, disco, rede, etc.) e a memória do sistema.
  • Elementos envolvidos: o periférico, o barramento do sistema, a memória e a \mathrm{CPU} (ou um controlador especializado).
  • Dois recursos limitantes: tempo da \mathrm{CPU} (quanto esforço a \mathrm{CPU} precisa gastar) e largura de banda do barramento/memória (quanto dado pode ser movido por unidade de tempo).
    Entender isso ajuda a ver por que existem três estratégias: cada uma equilibra uso da \mathrm{CPU}, complexidade e rendimento de formas diferentes.

Passo 3

\mathrm{E}/\mathrm{S} programada (polling) — o que é e como funciona, passo a passo:
  • Ideia central: a \mathrm{CPU} controla ativamente a transferência, consultando o dispositivo repetidamente até que ele esteja pronto.
  • Sequência típica (passos que você poderia escrever na prova):
    1. A \mathrm{CPU} escreve um comando no registrador do periférico para começar a operação (por ex.: ler um byte).
    2. A \mathrm{CPU} entra num laço de polling: lê o registrador de status do dispositivo repetidamente para ver se o bit “ready” ficou 1.
    3. Quando o status indica pronto, a \mathrm{CPU} lê (ou escreve) o dado no registrador de dados do periférico e move esse dado para a memória (ou do memória para o periférico).
    4. Repete até terminar a transferência completa.
  • Características importantes (explique na prova com frases curtas):
    • Uso de \mathrm{CPU}: alto. A \mathrm{CPU} fica ocupada verificando o status (wasteful).
    • Latência: baixa resposta imediata ao terminar o polling, mas ocupação da \mathrm{CPU} é alta.
    • Throughput: ruim para grandes blocos de dados porque a \mathrm{CPU} faz todo o trabalho palavra a palavra.
    • Complexidade: simples de implementar (boa para dispositivos lentos e simples).
  • Exemplo concreto para entender: teclado — se a \mathrm{CPU} ficasse verificando a cada ciclo se o usuário apertou tecla, isso gastaria muito tempo; por isso polling é ruim para entradas esporádicas.

Passo 4

\mathrm{E}/\mathrm{S} por interrupção — o que é e como funciona, passo a passo:
  • Ideia central: o periférico notifica a \mathrm{CPU} quando precisa de atenção, por meio de uma interrupção; a \mathrm{CPU} só age quando recebe esse sinal.
  • Sequência típica:
    1. \mathrm{CPU} programa o periférico iniciando a operação e habilita interrupções daquele dispositivo.
    2. A \mathrm{CPU} continua executando outras tarefas; não fica verificando o status.
    3. Quando o periférico está pronto (por exemplo, chegou um byte), ele gera uma interrupção ao controlador de interrupções.
    4. A \mathrm{CPU} suspende a tarefa atual, executa a rotina de tratamento de interrupção (ISR — Interrupt Service Routine) que lê/escreve o dado do registrador do periférico e possivelmente inicia a próxima transferência.
    5. A \mathrm{CPU} retorna à tarefa interrompida.
  • Características importantes:
    • Uso de \mathrm{CPU}: moderado. A \mathrm{CPU} só atua quando necessário (reduz desperdício em comparação ao polling).
    • Latência: boa resposta ao evento, mas há overhead de trocar contexto/entrar na ISR.
    • Throughput: melhor que polling para entradas esporádicas e moderadas; porém, para grandes blocos de dados contínuos, as muitas interrupções (uma por palavra/byte) ainda geram overhead elevado.
    • Complexidade: maior que polling (necessita vetor de interrupção, ISRs e sincronização).
  • Exemplo de uso ideal: teclado e mouse (event-driven); dispositivos que geram eventos discretos e não transferem grandes blocos contínuos.

Passo 5

\mathrm{DMA} (Direct Memory Access) — o que é e como funciona, passo a passo:
  • Ideia central: um controlador \mathrm{DMA} especializado move blocos de dados diretamente entre um periférico e a memória sem envolver a \mathrm{CPU} para cada palavra. A \mathrm{CPU} apenas configura a transferência e é notificada no fim.
  • Sequência típica:
    1. \mathrm{CPU} programa o controlador \mathrm{DMA} com: endereço de origem, endereço de destino, tamanho do bloco e direção (leitura ou escrita).
    2. \mathrm{CPU} inicia a operação \mathrm{DMA} e pode continuar outras tarefas.
    3. O controlador \mathrm{DMA} assume o barramento e realiza transferências de memória por bloco, copiando dados periférico↔memória sem intervenção da \mathrm{CPU}.
    4. Ao final da transferência o \mathrm{DMA} gera uma interrupção (ou seta um flag) para avisar que a operação terminou.
  • Modos de operação do \mathrm{DMA} (útil para prova):
    • Cycle stealing: \mathrm{DMA} rouba ciclos de barramento entre acessos da \mathrm{CPU} (menor impacto em latência de CPU, throughput moderado).
    • Burst mode: \mathrm{DMA} toma o barramento e transfere um grande bloco de uma vez (máximo throughput, maior latência para \mathrm{CPU}).
  • Características importantes:
    • Uso de \mathrm{CPU}: muito baixo durante a transferência (CPU livre para outras tarefas).
    • Latência: \mathrm{CPU} tem latência para acessar o barramento dependendo do modo do \mathrm{DMA}, mas transferências têm alto throughput.
    • Throughput: alto — ideal para discos, placas de rede, vídeo, qualquer dispositivo que mova grandes blocos de dados.
    • Complexidade: requer controlador \mathrm{DMA}, lógica de arbitragem do barramento e cuidado com sincronização/cache (problema prático: coerência de cache).
  • Exemplo de uso ideal: leitura de setores de disco para memória, envio/recebimento de pacotes de rede, transferência de frames de vídeo.

Passo 6

Comparação direta (forma que funciona bem em prova — pontos curtos):
  • Quem faz a cópia:
    • \mathrm{E}/\mathrm{S} programada: \mathrm{CPU} palavra a palavra.
    • \mathrm{E}/\mathrm{S} por interrupção: \mathrm{CPU} quando o periférico gera interrupção (por evento).
    • \mathrm{DMA}: controlador \mathrm{DMA} faz a cópia em bloco; \mathrm{CPU} só configura e finaliza.
  • Uso de \mathrm{CPU}:
    • Programada: elevado.
    • Interrupção: médio (atividade em eventos).
    • \mathrm{DMA}: baixo.
  • Overhead / eficiência:
    • Programada: ineficiente para grandes transferências.
    • Interrupção: eficiente para eventos esporádicos, ineficiente se interrupções forem muito frequentes.
    • \mathrm{DMA}: mais eficiente para grandes blocos (melhor throughput).
  • Complexidade de implementação:
    • Programada: simples.
    • Interrupção: requer ISRs e tratamento de concorrência.
    • \mathrm{DMA}: mais complexa (hardware adicional, arbitragem, coerência de cache).
  • Quando usar (regra prática):
    • Programada: dispositivos muito lentos e simples; quando simplicidade vence eficiência.
    • Interrupção: dispositivos de velocidade moderada com eventos esporádicos.
    • \mathrm{DMA}: transferências de alto volume (disco, rede, vídeo).

Passo 7

Cuidados e problemas práticos que caem na prova (e como responder):
  • Coerência com cache: \mathrm{DMA} pode deixar cache inconsistente — precisa de flush/invalidate; mencione isso se a questão exigir detalhes de sistema moderno.
  • Interrupções frequentes: se cada byte gera uma interrupção, a \mathrm{CPU} gasta muito tempo em ISRs — por isso existem modos híbridos (ex.: usar interrupção por bloco, não por byte).
  • Arbitragem do barramento: \mathrm{DMA} precisa disputar o barramento com a \mathrm{CPU} — cite cycle stealing vs burst como diferença importante.
    Dica rápida para prova: se o enunciado fala de “muitos dados” ou “alto throughput”, escreva \mathrm{DMA}; se fala de “evento” ou “tecla” escreva interrupção; se fala de “simples” ou “sistema embarcado muito básico”, polling pode ser aceitável.

Passo 8

Exemplos curtos tipo “responda na prova” (frases prontas):
  • Teclado: “usar \mathrm{E}/\mathrm{S} por interrupção — gera evento quando tecla pressionada.”
  • Transferir um arquivo do disco para RAM: “usar \mathrm{DMA} — eficiente para grandes blocos.”
  • Firmware simples sem \mathrm{DMA} em microcontrolador pequeno: “ \mathrm{E}/\mathrm{S} programada (polling) se simplicidade for prioridade.”

Passo 9

Resumo final motivacional (modo amigo): lembre assim — polling = ficar olhando (muito trabalho para \mathrm{CPU}), interrupção = bater na porta quando chegar algo (bom para eventos), \mathrm{DMA} = manda um ajudante que carrega o caminhão inteiro (melhor para muita carga). Você manda a ordem, e cada método tem o momento certo; na prova cite quem faz a cópia, uso de \mathrm{CPU}, throughput e um exemplo simples.

Resposta

\mathrm{E}/\mathrm{S} programada: a \mathrm{CPU} faz polling no dispositivo e transfere dados palavra a palavra; é simples, ocupa muito a \mathrm{CPU} e é ineficiente para grandes volumes.
\mathrm{E}/\mathrm{S} por interrupção: o dispositivo gera uma interrupção quando está pronto; a \mathrm{CPU} executa uma rotina (ISR) para transferir dados; reduz polling e é bom para eventos esporádicos, mas muitas interrupções degradam desempenho.
\mathrm{DMA}: um controlador \mathrm{DMA} transfere blocos direto entre periférico e memória sem intervenção contínua da \mathrm{CPU}; muito eficiente para grandes transferências (alto throughput), requer hardware extra e cuidados com coerência de cache.

Exercícios relacionados