A matemática real dos builds lentos em macOS

Em projetos iOS com dezenas de módulos e alguns anos de estrada, é assustadoramente comum encontrar pipelines de validação de Pull Request levando de 40 a 55 minutos. Muita gente se acostuma com essa lentidão como se fosse uma lei da natureza do Xcode, até colocar o impacto na ponta do lápis.

O prejuízo bate em duas frentes ao mesmo tempo. Na fatura de infraestrutura, minutos de runners macOS em nuvem costumam custar de cinco a dez vezes mais do que minutos de máquinas Linux equivalentes. No lado humano, que quase sempre sai mais caro, um pipeline de 45 minutos quebra completamente o foco do desenvolvedor: você abre o PR, muda para outra tarefa enquanto espera, recebe uma falha de lint ou teste uma hora depois e perde mais quinze minutos retomando o raciocínio original. Em uma equipe de 12 pessoas abrindo dois PRs por dia, reduzir o build de 45 para 10 minutos devolve dezenas de horas úteis toda semana. Se quiser simular esse custo com os números da sua equipe (tamanho do time, PRs por dia e tarifa do runner), use a calculadora interativa de ROI de CI/CD disponível aqui no site.

Alvo pragmático de produtividade: um pipeline de validação de Pull Request em iOS deveria fechar entre 8 e 12 minutos. Acima de 20 minutos, o time começa a agrupar mudanças grandes demais em um único PR para evitar a espera, o que piora a qualidade das revisões e aumenta o risco de regressão.

Meça antes de otimizar: perfilando cada etapa

O primeiro erro de quem tenta acelerar um pipeline é sair aplicando receitas prontas de cache sem medir onde o relógio realmente está parado. Em vários projetos que auditei, a equipe jurava que o gargalo era o compilador Swift, quando na verdade 14 minutos estavam indo embora baixando dependências externas sem cache, 6 minutos ligando um simulador frio e mais 5 minutos rodando scripts de geração de assets que nem precisavam executar em build de teste unitário.

Antes de mexer no YAML do CI, execute uma compilação limpa com o resumo de tempos do próprio xcodebuild e colete os tempos por fase do runner:

# Medir quanto cada etapa e cada target consome na compilação
xcodebuild build-for-testing \
  -workspace App.xcworkspace \
  -scheme AppTests \
  -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
  -showBuildTimingSummary

Com o relatório em mãos, separe o tempo total em cinco blocos: checkout e setup do ambiente, resolução de dependências (SPM/CocoaPods), compilação e linkagem, inicialização do simulador e execução da suíte de testes. Ataque sempre o maior bloco primeiro.

Alavancas de otimização e impacto real

A tabela abaixo resume as otimizações que costumam entregar maior redução de tempo em projetos iOS médios e grandes, junto com o risco operacional de cada escolha:

TécnicaGanho típico por buildEsforço de implantaçãoRisco ou trade-off principal
Cache de SPM / Pods e ferramentas (Bundler/Mint)3 a 9 minutosBaixo (1 dia)Chave de cache mal montada causa miss frequente ou dependências obsoletas.
Pré-compilar SDKs pesados em XCFramework4 a 12 minutosMédio (2 a 4 dias)Exige recompilar os binários quando a versão do Xcode ou do SDK muda.
build-for-testing + sharding de testes8 a 25 minutosMédio (3 a 5 dias)Consome mais concorrência de runners paralelos; requer testes independentes entre si.
Corrigir expressões lentas no type-checker Swift2 a 8 minutosBaixo a médioNenhum risco de cache; melhora também o build local na máquina de cada dev.
Desligar Run Scripts desnecessários em Debug/Test1 a 5 minutosBaixo (meio dia)Garantir que upload de dSYM e checagens de release continuem ativos em Archive.

Cache que funciona de verdade (e a armadilha do DerivedData)

Uma dica repetida em muitos blogs é colocar toda a pasta ~/Library/Developer/Xcode/DerivedData dentro do cache do GitHub Actions ou GitLab CI. Na prática, isso frequentemente piora o tempo total do pipeline. Em um projeto grande, o DerivedData passa facilmente de 4 GB a 8 GB. Comprimir, enviar pela rede ao fim do job e descompactar esse volume no job seguinte pode consumir seis minutos sozinho, além de provocar erros estranhos de módulos pré-compilados incompatíveis quando o caminho absoluto ou o timestamp muda entre runners efêmeros.

Em runners efêmeros na nuvem, o cache que realmente se paga é enxuto e determinístico: o diretório de checkouts do Swift Package Manager (usando a flag -clonedSourcePackagesDirPath), as gems do Ruby/Fastlane e binários pré-compilados de terceiros que raramente mudam. Deixe o cache de compilação incremental para máquinas Apple Silicon dedicadas (self-hosted) ou para ferramentas de cache remoto baseadas em hash de conteúdo (como Tuist Cache ou Bazel).

# Exemplo enxuto no GitHub Actions: cache determinístico de SPM sem inflar o runner
- name: Cache Swift Package Manager checkouts
  uses: actions/cache@v4
  with:
    path: SourcePackages
    key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
    restore-keys: |
      ${{ runner.os }}-spm-

- name: Compilar uma única vez para testes
  run: |
    xcodebuild build-for-testing \
      -workspace App.xcworkspace \
      -scheme AppPRValidation \
      -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
      -clonedSourcePackagesDirPath SourcePackages \
      -derivedDataPath BuildOutput \
      COMPILER_INDEX_STORE_ENABLE=NO

Repare na opção COMPILER_INDEX_STORE_ENABLE=NO no comando acima. O índice usado pelo autocomplete e navegação do Xcode não tem utilidade alguma dentro de um servidor de CI, mas costuma adicionar de 10% a 18% de sobrecarga de CPU e disco durante a compilação. Desligá-lo no CI economiza minutos de graça e ainda reduz o tamanho do artefato gerado.

Build uma vez, teste em paralelo

Quando a suíte passa de 2.500 testes unitários ou inclui dezenas de testes de interface, rodar tudo em fila única vira o principal gargalo. O segredo para escalar em matriz no CI sem pagar a conta da compilação várias vezes é quebrar o fluxo em dois estágios: o primeiro job executa build-for-testing e publica o diretório Build/Products (que contém o arquivo .xctestrun); em seguida, três ou quatro jobs paralelos baixam esse artefato e executam test-without-building, cada um rodando um .xctestplan ou um conjunto diferente de targets.

# Execução paralela em workers usando artefato já compilado
xcodebuild test-without-building \
  -xctestrun BuildOutput/Build/Products/AppPRValidation_iphonesimulator*.xctestrun \
  -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
  -only-testing:CoreNetworkingTests \
  -only-testing:PaymentsDomainTests \
  -parallel-testing-enabled YES \
  -parallel-testing-worker-count 3 \
  -resultBundlePath TestResults-Shard1.xcresult

Um detalhe importante de ajuste fino: não chute um número alto em -parallel-testing-worker-count. Em uma VM macOS com 3 ou 4 vCPUs, subir 6 clones de simuladores ao mesmo tempo gera contenção pesada de memória e I/O, deixando os testes mais lentos e intermitentes do que com 2 ou 3 workers. Teste na prática com 2, 3 e 4 workers e escolha o menor tempo médio estável. E lembre que paralelização exige isolamento rigoroso de rede e estado, como detalhado em ambientes herméticos de teste com mock servers.

Em bases maiores, a arquitetura do código também ajuda diretamente o CI. Se o projeto estiver bem dividido em módulos independentes (como discutido em arquitetura modular em iOS), um script simples baseado em git diff consegue identificar quais módulos foram tocados no Pull Request e executar primeiro apenas os testes daqueles módulos e de quem depende deles, reservando a suíte completa para a fila de merge.

Caçando gargalos escondidos no compilador Swift

Muitas vezes a lentidão do build vem de uma dúzia de arquivos específicos onde a inferência de tipos do Swift explode em complexidade exponencial. Operadores ternários encadeados, somas de arrays grandes em uma única expressão, dicionários literais extensos sem anotação de tipo e views SwiftUI gigantescas costumam travar um núcleo inteiro do processador por 10 a 30 segundos.

Adicione temporariamente estas flags nas configurações do target em Debug para listar exatamente quais funções e expressões passam de 100 milissegundos:

// Em Build Settings > Other Swift Flags (apenas Debug/Diagnóstico)
OTHER_SWIFT_FLAGS = -Xfrontend -warn-long-function-bodies=100 -Xfrontend -warn-long-expression-type-checking=100

Em um caso real que corrigi, uma única função que montava um dicionário de parâmetros analíticos com operadores ?? aninhados consumia 19 segundos a cada compilação incremental. Bastou declarar o tipo explícito var payload: [String: Any] = [:] e quebrar a montagem em atribuições diretas para o tempo daquele arquivo cair de 19 segundos para 40 milissegundos. Também confira se o esquema usado em validação de PR compila com SWIFT_COMPILATION_MODE = incremental (ou singlefile) e nível de otimização -Onone; deixar wholemodule e -O ligados em jobs de teste unitário duplica o tempo de compilação sem necessidade.

Plano prático de quatro semanas

Se o seu pipeline hoje passa de 35 minutos, não tente reescrever tudo em um fim de semana. Um plano gradual entrega retorno já na primeira sprint:

  1. Na primeira semana, colete os tempos das últimas 50 execuções, rode -showBuildTimingSummary e liste os três maiores ofensores reais do pipeline.
  2. Na segunda semana, ative cache de SourcePackages e gems, inclua COMPILER_INDEX_STORE_ENABLE=NO e impeça que Run Scripts exclusivos de release (como upload de dSYMs) rodem em builds de teste.
  3. Na terceira semana, ligue as flags de diagnóstico do Swift, corrija as 15 funções mais lentas do projeto e avalie empacotar SDKs de terceiros estáveis como XCFramework pré-compilado.
  4. Na quarta semana, separe build-for-testing de test-without-building, ajuste o número de workers paralelos ao hardware real do runner e acompanhe semanalmente os percentis p50 e p90 do tempo de build para barrar regressões silenciosas.