Performance no IOS: Entendendo Dynamic Dispatch e Static Dispatch

No Static Dispatch, o compilador sabe exatamente qual método será chamado durante a compilação. Isso permite que ele realize otimizações como o inlining, que consiste em substituir a chamada de uma função pelo seu próprio código, eliminando a sobrecarga da chamada e melhorando o desempenho.

Características:

•  Decidido em tempo de compilação.

•  Sem custo de lookup (busca dinâmica em tempo de execução).

•  Melhor performance.

•  Não permite sobrescrita (overriding) de métodos.

Quando ocorre:

• Métodos marcados como final (não podem ser sobrescritos).

•  Métodos em structs e enums (tipos por valor).

•  Funções static.

•  Métodos de classes marcados como final.

Já no Dynamic Dispatch, a decisão sobre qual método será executado acontece em tempo de execução, com base no tipo real do objeto. Isso permite polimorfismo, ou seja, que subclasses sobrescrevam métodos da superclasse e que o comportamento mude conforme a instância usada.

Para realizar essa decisão, o sistema utiliza estruturas como a dispatch table (ou vtable, "virtual method table") — uma tabela interna que armazena ponteiros para os métodos que podem ser chamados dinamicamente. Quando um método é invocado, o sistema faz um lookup (busca) nessa tabela para descobrir qual versão do método deve ser executada.

Características:

• Decidido em tempo de execução.

•  Permite sobrescrita de métodos.

•  Pequeno custo de lookup na dispatch table/vtable.

•  Suporte ao polimorfismo e runtime dinâmico.

Quando ocorre:

• Métodos de classes não marcados como final.

•  Métodos marcados com @objc.

•  Métodos declarados como dynamic.

• @objc: Indica que o método ou propriedade pode ser acessado pelo runtime do Objective-C. Isso é necessário quando você precisa de compatibilidade com APIs escritas em Objective-C ou quando usa mecanismos como Selector, notificações (NotificationCenter) ou KVO (Key-Value Observing).

• dynamic: Informa explicitamente que o método deve usar dynamic dispatch, mesmo em um contexto onde o Swift usaria dispatch estático. Todo método dynamic também é @objc automaticamente.

Selector: Um selector é uma forma de referenciar métodos por nome (como uma string) no runtime do Objective-C. É amplamente usado para chamadas dinâmicas, como no performSelector, target-action e observadores.

Exemplo prático:

Uma forma rápida de saber:

import Foundation

class DynamicClass {                                                                                              

         func compute() -> Int {

       return 42

            }

 }

 final class StaticClass {

            func compute() -> Int {

         return 42 }

 }

 struct StaticStruct {

             func compute() -> Int {

          return 42 }

 }

 func measure( label: String, block: ()-> Void) {

          let start CFAbsoluteTimeGetCurrent()

          block()

          let diff CFAbsoluteTimeGetCurrent() start

          print("\(label) took \(diff) seconds")

 }

 let dynamic DynamicClass()

 let staticStruct = StaticStruct()

let staticClass StaticClass()

let iterations = 1_000_000

measure("Dynamic Dispatch") {

            var result = 0

            for in 0..<iterations {

                       result += dynamic.compute()

            }

 assert(result > 0)

}

measure("Static Dispatch (final class)") {

             var result = 0

             for } in 0..citerations {

                         result += staticClass.compute()

                 }

            assert(result > 0)

measure("Static Dispatch (struct)”) {

            var result =0

            for _ in 0 ..siterations ( for result = staticStruct.compute()

                   }

              assert(result > 0)

}

• Static Dispatch: geralmente de 10% a 30% mais rápido dependendo do ambiente.

• Dynamic Dispatch: pequeno overhead devido ao lookup na vtable.

Deve-se considerar static dispatch em código de alto desempenho, como:

• Processamento gráfico.

• Algoritmos de machine learning no device.

• Processamento de áudio em tempo real.

•  Uso de “final” não só melhora a performance, mas também expressa intenção de design (prevenção de herança).

O Dynamic Dispatch oferece flexibilidade e suporte ao polimorfismo — essencial na programação orientada a objetos. Por outro lado, o Static Dispatch proporciona máxima performance, sendo favorecido em cenários com struct, enum, métodos static ou final.

Entender como e quando cada tipo de dispatch ocorre não só ajuda a otimizar a performance da sua aplicação, como também contribui para um design mais claro, robusto e seguro.

No Swift, equilibrar o uso de value types (como structs) e reference types (classes) vai além da modelagem de dados: impacta diretamente o desempenho da aplicação.