Swift e Objective-C

Meça MemoryLayout em Swift: size, stride e alignment

Meça structs reordenados, opcionais e um existential, separando o resultado observado de garantias de ABI e do uso total de memória no heap.

2 min de leitura
Imagem de capa de Meça MemoryLayout em Swift: size, stride e alignment

Para comparar o espaçamento entre elementos de um array, observe stride além de size. Size descreve o espaço do valor; stride inclui o ajuste de alinhamento até o próximo. Reordenar propriedades pode alterar o preenchimento e as duas medidas.

Mecanismo e decisão de projeto

Bad armazena Bool, Double, Int32; Good armazena Double, Int32, Bool. Double tem alinhamento 8 neste alvo, criando preenchimento após um campo pequeno. Confira compilador, alvo e definição do tipo; a ordem declarada não é um contrato permanente de ABI. Fonte primária

Código reproduzível

O experimento imprime size, stride e alignment dos tipos e mede Bool?, Int?, um existential de protocolo sem restrição de classe e um valor Array. Exige alvo de 64 bits e interrompe se houver diferença dos resultados registrados, evidenciando mudanças de ambiente.

Este exemplo independente foi executado em 2026-10-23 com Apple Swift 6.4 para arm64 macOS, no modo de linguagem Swift 6. Não requer rede nem pacotes adicionais.

Baixar o arquivo Swift completo

Execute o comando na pasta do download. As precondições interrompem a execução se uma verificação falhar. Não use -Ounchecked: essa opção remove as verificações.

swift -swift-version 6 swift-memory-layout-size-stride-alignment.swift
struct Bad {
    var flag: Bool
    var value: Double
    var count: Int32
}
struct Good {
    var value: Double
    var count: Int32
    var flag: Bool
}
protocol Shape {}

precondition(MemoryLayout<Int>.size == 8, "This experiment requires a 64-bit target")
let bad = (MemoryLayout<Bad>.size, MemoryLayout<Bad>.stride, MemoryLayout<Bad>.alignment)
let good = (MemoryLayout<Good>.size, MemoryLayout<Good>.stride, MemoryLayout<Good>.alignment)
print("bad=size:\(bad.0),stride:\(bad.1),alignment:\(bad.2)")
print("good=size:\(good.0),stride:\(good.1),alignment:\(good.2)")
print("optional=bool-size:\(MemoryLayout<Bool?>.size),int-size:\(MemoryLayout<Int?>.size),int-stride:\(MemoryLayout<Int?>.stride)")
print("existential=\(MemoryLayout<any Shape>.size) array-value=\(MemoryLayout<[Int]>.size)")
precondition(bad == (20, 24, 8) && good == (13, 16, 8), "Layout differs from the recorded toolchain")
precondition(MemoryLayout<Bool?>.size == 1 && MemoryLayout<Int?>.size == 9)
precondition(MemoryLayout<Int?>.stride == 16 && MemoryLayout<any Shape>.size == 40)
precondition(MemoryLayout<[Int]>.size == 8)

Saída registrada e interpretação

bad=size:20,stride:24,alignment:8
good=size:13,stride:16,alignment:8
optional=bool-size:1,int-size:9,int-stride:16
existential=40 array-value=8

Bad teve size 20 e stride 24; Good teve size 13 e stride 16. Um milhão de elementos contíguos representa 8,000,000 bytes de diferença apenas pelo stride. Bool? teve size 1; Int?, size 9 e stride 16; any Shape, 40; e o valor Array, 8.

Escopo e limitações

Um valor Array de 8 bytes não contém todos os elementos. O armazenamento no heap e o custo do alocador ficam fora da medida. Os 40 bytes do existential também não valem para todo tipo any. São observações no alvo registrado, não garantias para outros.

O que verificar em seguida

Meça primeiro a quantidade de instâncias e as alocações no heap. Considere reordenar propriedades apenas quando o preenchimento importar em uma coleção grande, verificando compatibilidade de API. Se valores e referências não estiverem claros, comece pelo experimento class versus struct.

Experimento relacionado

Fontes e verificação

  • Swift ABI: Type LayoutSwift.org · Documentação oficial · Consultado 23 de outubro de 2026Evidência: Fonte do contrato de implementação e da explicação. A saída foi verificada separadamente com o experimento incluído aqui.