Quando devo usar anotações de tipo para variáveis, argumentos e tipos de retorno em Julia?

Como argumento de função você anota para asserção ou para implementar despacho múltiplo, mas não para performances.

O mesmo em geral para anotação de variáveis, exceto um caso específico que são membros de struct, onde a anotação de todos os membros fará uma grande diferença.

Apenas um caso importante que não foi abordado por Antonello.

Não consigo encontrar onde estão as menções em quais "casos" especificamente as anotações de tipo ajudam a melhorar o desempenho.

O caso em que a anotação de tipo ajuda é quando o tipo não pode ser deduzido em tempo de compilação. Aqui está um exemplo:

julia> v = collect(Any, rand(1:10, 10^7));

julia> function f1(x::AbstractVector)
           s = 0
           for i in eachindex(x)
               v = x[i]
               a = v + v
               b = 2 + v
               c = v - 1
               d = a + c
               e = a - b + c - v
               s += e
           end
           return s
       end
f1 (generic function with 1 method)

julia> function f2(x::AbstractVector)
           s = 0
           for i in eachindex(x)
               v::Int = x[i]
               a = v + v
               b = 2 + v
               c = v - 1
               d = a + c
               e = a - b + c - v
               s += e
           end
           return s
       end
f2 (generic function with 1 method)

julia> @time f1(v)
  1.055734 seconds (10.00 M allocations: 152.800 MiB, 1.03% gc time, 0.76% compilation time)
24995270

julia> @time f1(v)
  1.178262 seconds (10.00 M allocations: 152.585 MiB, 0.45% gc time)
24995270

julia> @time f2(v)
  0.688447 seconds (3.46 k allocations: 226.578 KiB, 1.75% compilation time)
24995270

julia> @time f2(v)
  0.716612 seconds (1 allocation: 16 bytes)
24995270

julia> function sum1(x::AbstractVector)
           s = 0
           for i in eachindex(x)
               v = x[i]
               s += v
           end
           return s
       end
sum1 (generic function with 1 method)

julia> function sum2(x::AbstractVector)
           s = 0
           for i in eachindex(x)
               v::Int = x[i]
               s += v
           end
           return s
       end
sum2 (generic function with 1 method)

julia> @time sum1(v);
  0.260931 seconds (10.00 M allocations: 152.752 MiB, 17.27% gc time, 2.90% compilation time)

julia> @time sum1(v);
  0.227542 seconds (10.00 M allocations: 152.586 MiB, 2.32% gc time)

julia> @time sum2(v);
  0.738166 seconds (2.51 k allocations: 167.264 KiB, 1.08% compilation time)

julia> @time sum2(v);
  0.761652 seconds (1 allocation: 16 bytes)

O que você vê aqui é o fato de que quando escrevemos v::Int = x[i]o código dentro do loop é do tipo estável. Quando escrevemos, v = x[i]o código não é de tipo estável e causa alocações.

Você pode então perguntar por que sum1(not type stable) é mais rápido que sum2(type stable). A razão é que quando escrevemos v::Int = x[i]não é apenas uma afirmação de tipo. Na verdade, é um requisito de conversão de tipo; por exemplo, se x[i]fosse Bool, seria convertido para Int. O fato de a conversão ser tentada também custa caro. O custo de conversão das funções f1e f2é muito menor que o overhead causado pelas operações em valores instáveis ​​do tipo. Mas nas funções sum1e sum2o oposto é verdadeiro.

Em resumo - as coisas não são óbvias (e podem até mudar nas versões de Julia). É por isso que o Manual Julia não pode fornecer uma regra precisa.

Além disso, o que é relevante saber é que:

• quando você anota uma variável ou valor de retorno de uma conversão de função é tentada
• quando você anota a conversão do parâmetro de função não é tentada (esta anotação é usada para envio)