0Pricing
Swift Academy · Aula

Otimização de caminhos críticos: COW, inlining e especialização

Aplique @inline, @_specialize e otimizações de tipos por valor com base nos dados do profiler.

Otimização de caminhos críticos: COW, inlining e especialização é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Identifique antes de otimizar

Sempre faça uma análise de desempenho primeiro. Otimize apenas o código que o Time Profiler identifica como um caminho crítico — a otimização prematura desperdiça tempo.

// Measure → Identify → Optimise → Re-measure
// A 10ms function called once is less important than
// a 0.1ms function called 10,000 times per frame

Cópia na escrita (COW)

Tipos de valor do Swift (Array, Dictionary) usam COW: o armazenamento é compartilhado até ocorrer uma mutação, evitando cópias desnecessárias.

var a = [1, 2, 3, 4, 5]
var b = a         // no copy yet, shared buffer
b.append(6)       // copy happens here (b mutates)
print(a.count)    // 5 — a unchanged

Garantindo COW em tipos personalizados

Implemente COW em tipos de valor personalizados encapsulando o estado mutável em um tipo por referência e copiando-o antes da mutação.

struct Matrix {
  private class Storage { var data: [[Double]] }
  private var storage = Storage()
  private mutating func ensureUnique() {
    if !isKnownUniquelyReferenced(&storage) {
      storage = Storage(data: storage.data)  // copy on write
    }
  }
  mutating func set(row: Int, col: Int, value: Double) {
    ensureUnique()
    storage.data[row][col] = value
  }
}

@inline(__always)

Force o compilador a inserir uma função em cada ponto de chamada, eliminando a sobrecarga de chamadas para funções pequenas executadas em ciclos apertados.

@inline(__always)
func clamp(_ value: Float, _ min: Float, _ max: Float) -> Float {
  return Swift.max(min, Swift.min(max, value))
}

@inline(never)

Impeça a inserção para reduzir o tamanho do código ou forçar o compilador a tratar um caminho como frio (raro).

@inline(never)
func handleUnexpectedError(_ error: Error) {
  // Large error-handling block — never inline to keep hot path small
}

@_specialize para genéricos

Instrua o compilador a emitir uma cópia especializada de uma função genérica para um tipo específico, permitindo despacho estático e otimizações SIMD.

@_specialize(where T == Float)
@_specialize(where T == Double)
func normalize<T: FloatingPoint>(_ values: [T]) -> [T] {
  let max = values.max()!
  return values.map { $0 / max }
}

Otimização de módulo inteiro

O WMO (ativado em Release) permite que o compilador faça inserções e especializações entre limites de arquivos dentro de um módulo.

// Xcode: Build Settings → Swift Compiler → Code Generation
// Optimization Level: Optimize for Speed (-O)
// Compilation Mode: Whole Module
// Enables cross-file inlining and dead code elimination

Evitando a sobrecarga do ARC

A criação frequente de tipos por referência em caminhos críticos causa sobrecarga de retenção e liberação do ARC. Prefira tipos de valor ou armazene referências em cache.

// HOT PATH:
for _ in 0..<1_000_000 {
  let obj = HeavyClass()  // alloc + dealloc + ARC overhead
}
// BETTER: allocate once outside the loop
let obj = HeavyClass()
for _ in 0..<1_000_000 { obj.process() }

Usando ContiguousArray

ContiguousArray garante armazenamento contíguo (ao contrário de Array para elementos de classe), melhorando o desempenho do cache em ciclos apertados.

var nums = ContiguousArray<Float>(repeating: 0, count: 10_000)
// Faster iteration than Array<Float> for bridged-to-ObjC types

Reduzindo consultas à tabela de testemunhas de protocolos

O despacho dinâmico de protocolos usa tabelas de testemunhas. Genéricos e especialização substituem as consultas às tabelas de testemunhas por chamadas diretas.

// Dynamic dispatch (slower for hot path):
func process(_ drawable: any Drawable) { drawable.draw() }
// Static dispatch after specialization:
func process<T: Drawable>(_ drawable: T) { drawable.draw() }
// Compiler may devirtualize and inline

Criando benchmarks com XCTMeasure

Sempre valide as otimizações com benchmarks de XCTMeasure no seu conjunto de testes para evitar regressões.

func testNormalizePerformance() {
  let data = Array(0..<100_000).map { Float($0) }
  measure {
    _ = normalize(data)
  }
}

Verificação rápida

O que isKnownUniquelyReferenced(_:) verifica ao implementar a cópia na escrita?

Recapitulação da lição

Faça primeiro a análise com o Instruments. Confie no COW integrado do Swift para coleções; implemente-o em tipos de valor personalizados com isKnownUniquelyReferenced. Use @inline(__always) para funções pequenas em caminhos críticos, @_specialize para pontos críticos genéricos e ative o WMO em compilações Release. Valide cada otimização com benchmarks de XCTMeasure.

Perguntas Frequentes

A aula “Otimização de caminhos críticos: COW, inlining e especialização” é grátis?

Sim — o texto completo de “Otimização de caminhos críticos: COW, inlining e especialização” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Otimização de caminhos críticos: COW, inlining e especialização”?

Aplique @inline, @_specialize e otimizações de tipos por valor com base nos dados do profiler. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Otimização de caminhos críticos: COW, inlining e especialização”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Fundamentos do Instruments: Time Profiler
  2. Instruments Allocations e Leaks
  3. Main Thread Checker e travamentos
  4. Otimização de caminhos críticos: COW, inlining e especialização
← Voltar para Swift Academy