FPGAs e HDLs

O que e uma FPGA?

Uma FPGA (Field-Programmable Gate Array) e um chip de logica digital cujo circuito interno pode ser reconfigurado pelo usuario apos a fabricacao. Diferente de um microcontrolador (que executa software sequencialmente), uma FPGA implementa circuitos digitais em hardware — toda a logica opera em paralelo.

  Caracteristica      CPU/MCU              FPGA                ASIC
  ────────────────────────────────────────────────────────────────────
  Programacao         Software (C/asm)     HDL (VHDL/Verilog)  RTL + fabricacao
  Execucao            Sequencial           Paralela             Paralela
  Reconfiguravel      Sim (software)       Sim (bitstream)      Nao
  Desempenho          Moderado             Alto                 Maximo
  Consumo             Moderado             Moderado-Alto        Baixo
  Custo unitario      Baixo                Medio                Alto (NRE*)
  Time-to-market      Rapido               Medio                Lento
  Uso                 Uso geral            Prototipagem, DSP    Producao em massa

  * NRE = Non-Recurring Engineering (custo inicial de projeto e mascaras)

Arquitetura Interna de uma FPGA

Uma FPGA e composta por três elementos fundamentais, repetidos em um array bidimensional:

CLBs (Configurable Logic Blocks)

Cada CLB contem LUTs (Look-Up Tables), flip-flops e multiplexadores. Uma LUT de 4 entradas pode implementar qualquer funcao logica de 4 variaveis — e essencialmente uma memoria SRAM de 16 posicoes cujas saidas sao a tabela verdade da funcao desejada.

  ┌─────────────────────────────────────┐
  │              CLB (Slice)             │
  │                                      │
  │   ┌──────────────┐    ┌─────────┐   │
  │   │   LUT-4      │    │  Flip-  │   │
  │   │  (16x1 SRAM) │───>│  Flop   │──>│── saida
  │   │              │    │  (D-FF) │   │
  │   │  A ──┐       │    └────┬────┘   │
  │   │  B ──┤ 16:1  │         │        │
  │   │  C ──┤  MUX  │    ┌────┴────┐   │
  │   │  D ──┘       │    │  MUX    │   │  ← saida combinacional
  │   └──────────────┘    │  sel    │   │    ou registrada
  │                       └─────────┘   │
  │   ┌──────────────┐                  │
  │   │  Carry Chain │  ← para aritmetica rapida  │
  │   └──────────────┘                  │
  └─────────────────────────────────────┘

  Uma LUT-4 implementa QUALQUER funcao de 4 variaveis:
  AND, OR, XOR, mux, somador de 1 bit, etc.
  Os 16 bits de configuracao sao carregados da bitstream.

Interconexao Programavel

Uma rede de fios e switch boxes (matrizes de comutacao) conecta os CLBs entre si. A configuracao define quais fios estao conectados, implementando a "fiacao" do circuito. A interconexao consome a maior parte da area e do atraso de uma FPGA.

Blocos de I/O (IOBs)

Pinos de entrada/saida configuraveis na periferia do chip. Suportam diferentes padroes de tensao (LVCMOS, LVDS, SSTL) e podem incluir resistores de pull-up/down, buffers diferenciais e registradores de I/O.

HDLs — Linguagens de Descricao de Hardware

Para programar FPGAs, usamos HDLs (Hardware Description Languages). As duas mais importantes sao VHDL e Verilog. Diferente de linguagens de software (C, Python), HDLs descrevem circuitos — o codigo nao e executado sequencialmente, mas sim sintetizado em logica paralela.

VHDL vs. Verilog

  Caracteristica      VHDL                    Verilog
  ────────────────────────────────────────────────────────
  Origem              DoD (EUA, 1987)         Gateway Design (1984)
  Tipagem             Forte (tipada)          Fraca
  Verbosidade         Alta                    Baixa (similar a C)
  Case-sensitive      Nao                     Sim
  Entidade/modulo     entity + architecture   module
  Sinais              signal                  wire / reg
  Atribuicao          <= (signal)             = (blocking)
                      := (variable)           <= (non-blocking)
  Popular em          Europa, academia,       EUA, industria,
                      defesa                  startups

Exemplo 1: Porta AND de 2 entradas

-- Porta AND em VHDL
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity porta_and is
    port (
        a : in  std_logic;
        b : in  std_logic;
        y : out std_logic
    );
end porta_and;

architecture rtl of porta_and is
begin
    y <= a and b;
end rtl;

// Porta AND em Verilog
module porta_and (
    input  a,
    input  b,
    output y
);
    assign y = a & b;
endmodule

Exemplo 2: Contador de 8 bits com reset

-- Contador de 8 bits sincrono com reset
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity contador_8bit is
    port (
        clk   : in  std_logic;
        reset : in  std_logic;
        count : out std_logic_vector(7 downto 0)
    );
end contador_8bit;

architecture rtl of contador_8bit is
    signal counter_reg : unsigned(7 downto 0);
begin
    process(clk, reset)
    begin
        if reset = '1' then
            counter_reg <= (others => '0');
        elsif rising_edge(clk) then
            counter_reg <= counter_reg + 1;
        end if;
    end process;

    count <= std_logic_vector(counter_reg);
end rtl;

// Contador de 8 bits sincrono com reset
module contador_8bit (
    input            clk,
    input            reset,
    output reg [7:0] count
);
    always @(posedge clk or posedge reset) begin
        if (reset)
            count <= 8'b0;
        else
            count <= count + 1;
    end
endmodule

Sintese vs. Simulacao

O fluxo de projeto em FPGA envolve duas atividades complementares:

• Simulacao: verifica o comportamento do circuito antes de implementar no hardware. Usa um testbench (arquivo de teste) que gera estimulos e verifica as saidas. Ferramentas: ModelSim, GHDL, Verilator, Icarus Verilog.
• Sintese: traduz a descricao HDL em um circuito de portas logicas e flip-flops, depois mapeia esse circuito nos recursos da FPGA (LUTs, BRAMs, DSPs). Ferramentas: Vivado (Xilinx/AMD), Quartus (Intel/Altera), Yosys (open-source).

  Codigo HDL  →  Simulacao  →  Sintese  →  Implementacao  →  Bitstream
  (VHDL/       (testbench     (netlist     (Place & Route    (arquivo de
   Verilog)     funcional)     de gates)    no chip)          configuracao)
                    │              │              │               │
                    v              v              v               v
               Comportamento  Otimizacao     Timing         Upload para
               correto?       de area/       closure?       a FPGA
                              velocidade

  Tempo tipico: horas (sintese + Place&Route para designs grandes)

Vantagens da Reconfigurabilidade

A grande vantagem das FPGAs e a reconfigurabilidade:

• Prototipagem rapida: testar um design de ASIC em hardware real antes de gastar milhoes na fabricacao
• Aceleracao de algoritmos: implementar funcoes computacionalmente intensivas (criptografia, processamento de video, inferência de ML) em hardware paralelo, alcancando throughput muito superior a uma CPU
• Atualizacao em campo: corrigir bugs ou adicionar funcionalidades apos o produto ser entregue ao cliente — basta enviar uma nova bitstream
• Low-volume production: para produtos com menos de ~100.000 unidades, uma FPGA pode ser mais barata que um ASIC (cujo NRE pode ultrapassar $1M)

No harness.os

FPGAs e HDLs oferecem metaforas interessantes para o harness.os:

• FPGA = Configuracao do harness: assim como uma FPGA e hardware reconfiguravel (o circuito muda sem trocar o chip), o harness.os e um framework reconfiguravel — as regras, workflows e conhecimento mudam sem reescrever o codigo do MCP server. A "bitstream" do harness e sua configuracao.
• HDL = Linguagem declarativa: HDLs descrevem o que o circuito e (nao como executar passo a passo). Regras do harness.os sao igualmente declarativas — descrevem restricoes e comportamentos, nao procedimentos. O "sintetizador" e o agente que interpreta as regras.
• Parallelismo = Agentes concorrentes: em uma FPGA, tudo executa em paralelo por padrao. No harness.os, agentes paralelos executam tarefas concorrentes — o parallelismo e uma feature, nao uma excecao.
• Sintese vs. simulacao = Staging vs. producao: simulacao verifica o design antes de implementar. No harness.os, branches de teste e ambientes de staging servem o mesmo proposito — validar antes de aplicar.

Exercicios

1. Escreva um modulo em VHDL ou Verilog que implementa um multiplexador 4:1 com entrada de selecao de 2 bits.
2. Uma LUT de 4 entradas pode implementar qualquer funcao logica de ate 4 variaveis. Quantas funcoes logicas distintas de 4 variaveis existem? (Dica: quantas tabelas verdade diferentes sao possiveis?)
3. Escreva um testbench em Verilog para o contador de 8 bits apresentado nesta aula. O testbench deve gerar clock, aplicar reset, e verificar que o contador conta corretamente de 0 a 255.
4. Compare o custo total de usar uma FPGA vs. um ASIC para um produto com volume de 1.000 unidades vs. 1.000.000 unidades. Assuma: FPGA=$15/unidade, ASIC NRE=$2M + $2/unidade.
5. Explique a diferenca entre atribuicao blocking (=) e non-blocking (<=) em Verilog. Por que usar non-blocking dentro de blocos always @(posedge clk)?

Resumo

• FPGAs sao chips de logica reconfiguravel compostos por CLBs (LUTs + flip-flops), interconexao e blocos de I/O
• Uma LUT de 4 entradas implementa qualquer funcao logica de 4 variaveis usando 16 bits de SRAM
• VHDL (verbose, tipada) e Verilog (concisa, tipo C) sao as duas HDLs dominantes
• O fluxo FPGA: codigo HDL → simulacao → sintese → place & route → bitstream
• Vantagens: prototipagem rapida, paralelismo nativo, reconfigurabilidade, aceleracao de algoritmos
• FPGAs competem com ASICs em volume baixo-medio e com CPUs em paralelismo