DS & II

Capítulo 14 - Otimização de Código

Leitura de 4 min

🚀 Capítulo 14: Otimização de Código (Tema: Flash)

NOTE

Este capítulo utiliza a temática de Flash para explicar a Otimização de Código. Não perca tempo dando voltas ou fazendo movimentos desnecessários: vá direto ao ponto na velocidade da luz!

1. 🎯 Objetivo da Aula

Compreender a fase de Otimização de Código de um compilador, entendendo como ele reescreve o código intermediário para que ele rode mais rápido e use menos memória, sem alterar o resultado final.

2. 🏢 O Cenário Prático (Seu Desafio)

O herói Flash consegue correr na velocidade da luz. Para ser tão rápido, ele não pode desperdiçar energia dando voltas desnecessárias ou carregando peso que não precisa. Ele sempre pega o caminho mais curto e eficiente.

O compilador faz exatamente isso na fase de Otimização de Código. Os programadores humanos muitas vezes escrevem códigos que funcionam, mas que fazem o computador trabalhar mais do que o necessário. O compilador lê o Código Intermediário e tenta deixá-lo mais “magro” e veloz antes de mandar para o processador! Seu desafio é correr na velocidade do Flash!

🧠 Fundamentos: A Teoria Traduzida

A otimização pode ser feita para deixar o programa mais rápido (velocidade) ou menor (ocupando menos espaço na memória).

✂️ Técnicas Comuns de Otimização:

1. Dobradura de Constantes (Constant Folding):

Se você escrever no código: tempo = 60 * 60; (para calcular os segundos em uma hora).

  • Sem Otimização: O computador calcula toda vez que o programa rodar.
  • Com Otimização: O compilador calcula isso na hora de compilar () e reescreve o seu código como: tempo = 3600;. O computador do usuário não precisa fazer a conta!

2. Eliminação de Código Morto (Dead Code Elimination):

Se você escrever um código que nunca será executado:

int x = 10;
return x;
x = x + 5; // Essa linha nunca vai rodar porque o return já aconteceu!
  • O compilador simplesmente apaga a linha x = x + 5 para o arquivo final ficar menor!

3. Propagação de Constantes:

int x = 10;
int y = x + 5;
  • O compilador percebe que x é sempre 10 e já calcula y = 15 direto.

4. 📖 Exemplo Guiado: Otimizando Loops

Olhe este loop que soma os números de um array de 3 posições:

for (int i = 0; i < 3; i++) {
    soma += arr[i];
}

Para rodar esse loop, a CPU precisa testar se i < 3 três vezes. O compilador pode otimizar isso fazendo o Loop Unrolling (Desenrolar o loop):

soma += arr[0];
soma += arr[1];
soma += arr[2];

O código ficou maior no arquivo, mas roda muito mais rápido porque a CPU não precisa ficar fazendo testes de “se” a cada volta!

5. 🛠️ Prática Obrigatória 1: Otimizando o Código

Otimize o seguinte trecho de código usando as técnicas que aprendemos (Constant Folding e Dead Code Elimination):

int a = 10 + 5;
int b = 20;
return a + b;
int c = a * b; // Linha extra

Como ficaria o código final otimizado pelo compilador?

6. 🛠️ Prática Obrigatória 2: O Custo do Flash

Vimos que o compilador gasta tempo e memória dele mesmo para tentar deixar o seu programa mais rápido.

  1. Por que em jogos de videogame nós ativamos a otimização máxima do compilador, mesmo que ele demore horas para terminar de compilar o jogo na empresa?

7. 📤 Instruções de Entrega (GitHub Desktop + Microsoft Teams)

  1. Faça o Commit: No GitHub Desktop, digite a mensagem (ex: Finaliza Capítulo 14 Hardware) e clique em Commit to main.
  2. Envie para a Nuvem (Push): Clique em Push origin.

8. 📂 Estrutura de Pastas

mod_14_hardware_e_compiladores/
├── capitulos/
│   ├── capitulo_14_otimizacao.md
│   └── codigos/
│       └── cap14/
│           └── codigo_otimizado.txt

💡 Checkpoint de Lógica

As otimizações mais avançadas são difíceis de entender até para programadores experientes. Os compiladores modernos (como o GCC) possuem centenas de técnicas matemáticas para espremer o máximo de desempenho do silício!

10. 🔥 Desafio de Fixação

Pesquise o que significa a sigla O2 ou O3 quando passamos parâmetros para compilar um código em C++ no terminal (Dica: Tem a ver com o nível de otimização).

🔑 Gabarito de Código/Fórmulas

Gabarito da Prática 1: O código otimizado seria apenas: return 35;

  • a virou 15 ().
  • b era 20.
  • O retorno virou 35 ().
  • A linha do int c foi apagada por ser código morto. Gabarito da Prática 2:
  1. Porque o jogo será compilado apenas uma vez na empresa, mas será jogado milhões de vezes pelos clientes. Vale a pena demorar mais na empresa para garantir que o cliente tenha um jogo fluido e sem travamentos.

← Capitulo Anterior | Proximo Capitulo →

Visão de gráfico

Backlinks