performance - julia:关于函数中泛型类型的几个问题

Question

我正在为一些函数添加类型，即速度和清晰度。我对此有几个问题。我在这里问他们所有人，因为我看到其他帖子这样做了。问题以粗体显示，以便于识别。
有一个函数我想添加类型来计算向量中负值的数量。我想让它与 Int 和 Float 兼容，就像无类型函数一样。虽然方便，但 Chris Rackauckas 建议不要这样做，请参阅 How to declare array type that can have int and floats 的第一条评论,

Do you want Ints and Floats at the same time? That's not advised due to performance reasons. But if you want to, you can use Union{Int64,Float64} as the type.

如果出于某种原因需要多态函数，那么更好的方法似乎是通过 Union 向参数添加类型。 .但是，对于这种特殊情况，使用 Number和 Real是 Int64 的父类(super class)型和 Float64 ，我认为这些会比无类型版本稍快。
然而，情况似乎并非如此，至少在我的简单测试中是如此。我测试了一个没有参数类型的函数，另一个带有 Any , 和两个类型 Number和 Real , Float64 的两个父类(super class)型和 Int64 .

notypes
median time:      1.006 ms (0.00% GC)
mean time:        1.152 ms (12.60% GC)

any
median time:      1.054 ms (0.00% GC)
mean time:        1.197 ms (12.05% GC)

union
median time:      1.062 ms (0.00% GC)
mean time:        1.210 ms (12.09% GC)

number
median time:      1.110 ms (0.00% GC)
mean time:        1.315 ms (14.18% GC)

real
median time:      1.015 ms (0.00% GC)
mean time:        1.168 ms (12.70% GC)

float
median time:      728.131 μs (0.00% GC)
mean time:        829.031 μs (11.53% GC)

显然，无类型函数与类型为 Any 的函数之间没有显着改进。和 Number . Real功能似乎有非常细微的改进，而 Float64功能是唯一有明显改进的。
是仅为 Int 键入的函数和 Float通常比没有类型的更快？ Union{Int64,Float64}是只有两种类型的父类(super class)型，不像 Number和 Real跨越更多。这就是为什么我认为 Union函数会比其他函数更快(除了 Float 版本)。 是 Union s 和无类型一样慢？
键入具有父类(super class)型(例如 Number)的函数是否有任何性能改进和 Float , 与让它们保持无类型相比？
为每个可能的参数类型定义一个函数是最好的朱利安实践吗？ 在这种情况下， Int64和 Float64 .
为了方便而不是性能， 有没有更短的方法来定义 Int-Float 函数？ 也许，通过在开始时定义一个新类型？我试过这样做:

abstract type IF64 <: Union{Int64,Float64} end

但出现错误

invalid subtyping in definition of IF64

另外， N 是什么？在函数的定义中是什么意思？ (例如 where {T<:Union{Int64,Float64},N} 中的 countMPvec_arrUnion 定义如下)。
最后， 为什么Float函数比其他函数占用更少的内存？ ( 609.06 KiB v. 921.56 KiB )(这是基准测试的输出；代码如下)

all other functions
  memory estimate:  921.56 KiB
  allocs estimate:  38979
float
  memory estimate:  609.06 KiB
  allocs estimate:  28979

测试的完整代码:

#= -------------------
   The different versions of the function
   -------------------
=#
function countMPvec_notypes(vec)
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

function countMPvec_any(vec :: Any)
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

# Works with Int and Float !!!
function countMPvec_arrUnion(vec :: Array{T,1}) where {T<:Union{Int64,Float64},N}
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

# Works with Int and Float !!!
function countMPvec_arrNumber(vec :: Array{T,1}) where {T<:Number,N}
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

# Works with Int and Float !!!
function countMPvec_arrReal(vec :: Array{T,1}) where {T<:Real,N}
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

function countMPvec_arrFloat(vec :: Array{Float64,1})
    nneg = 0
    lvec = length(vec)
    for i in 1:lvec
        if (vec[i] < 0)
            nneg += 1
        end
    end
    npos = lvec - nneg
    return (nneg,npos)
end

#= -------------------
   Functions for benchmark
   -------------------
=#
nums = [1.3; -2; 5]
nitertest = 10000

function test_notypes()
    for i in 1:nitertest
        countMPvec_notypes(nums)
    end
end
function test_any()
    for i in 1:nitertest
        countMPvec_any(nums)
    end
end
function test_arrUnion()
    for i in 1:nitertest
        countMPvec_arrUnion(nums)
    end
end
function test_arrNumber()
    for i in 1:nitertest
        countMPvec_arrNumber(nums)
    end
end
function test_arrReal()
    for i in 1:nitertest
        countMPvec_arrReal(nums)
    end
end
function test_arrFloat()
    for i in 1:nitertest
        countMPvec_arrFloat(nums)
    end
end

然后是基准单元。每一个都应该单独运行。此外，最后给出了每个单元格的完整输出:

import BenchmarkTools
println("notypes")
@BenchmarkTools.benchmark test_notypes()

println("any")
@BenchmarkTools.benchmark test_any()

println("union")
@BenchmarkTools.benchmark test_arrUnion()

println("number")
@BenchmarkTools.benchmark test_arrNumber()

println("real")
@BenchmarkTools.benchmark test_arrReal()

println("float")
@BenchmarkTools.benchmark test_arrFloat()

#= -------------------
   Output of the benchmarks
   -------------------
=#

notypes
BenchmarkTools.Trial: 
  memory estimate:  921.56 KiB
  allocs estimate:  38979
  --------------
  minimum time:     855.070 μs (0.00% GC)
  median time:      1.006 ms (0.00% GC)
  mean time:        1.152 ms (12.60% GC)
  maximum time:     31.515 ms (91.59% GC)
  --------------
  samples:          4314
  evals/sample:     1

any
BenchmarkTools.Trial: 
  memory estimate:  921.56 KiB
  allocs estimate:  38979
  --------------
  minimum time:     905.317 μs (0.00% GC)
  median time:      1.054 ms (0.00% GC)
  mean time:        1.197 ms (12.05% GC)
  maximum time:     30.355 ms (96.33% GC)
  --------------
  samples:          4152
  evals/sample:     1

union
BenchmarkTools.Trial: 
  memory estimate:  921.56 KiB
  allocs estimate:  38979
  --------------
  minimum time:     914.563 μs (0.00% GC)
  median time:      1.062 ms (0.00% GC)
  mean time:        1.210 ms (12.09% GC)
  maximum time:     32.472 ms (90.09% GC)
  --------------
  samples:          4111
  evals/sample:     1

number
BenchmarkTools.Trial: 
  memory estimate:  921.56 KiB
  allocs estimate:  38979
  --------------
  minimum time:     926.189 μs (0.00% GC)
  median time:      1.110 ms (0.00% GC)
  mean time:        1.315 ms (14.18% GC)
  maximum time:     42.545 ms (97.21% GC)
  --------------
  samples:          3788
  evals/sample:     1

real
BenchmarkTools.Trial: 
  memory estimate:  921.56 KiB
  allocs estimate:  38979
  --------------
  minimum time:     863.699 μs (0.00% GC)
  median time:      1.015 ms (0.00% GC)
  mean time:        1.168 ms (12.70% GC)
  maximum time:     31.847 ms (96.50% GC)
  --------------
  samples:          4257
  evals/sample:     1

float
BenchmarkTools.Trial: 
  memory estimate:  609.06 KiB
  allocs estimate:  28979
  --------------
  minimum time:     625.845 μs (0.00% GC)
  median time:      728.131 μs (0.00% GC)
  mean time:        829.031 μs (11.53% GC)
  maximum time:     30.811 ms (97.38% GC)
  --------------
  samples:          5989
  evals/sample:     1

Answer 1

所有与性能相关的问题都有一个答案:类型注释提高了结构的性能，但通常不会提高函数的性能。您从 Chris 那里读到的帖子涉及数组(结构)的元素类型，即使它出现在函数可接受的类型方面。你应该在那个上下文中解释它。
在 Julia 中，您应该对函数参数进行类型注释以控制调度，而不是为了性能。为什么？因为编译器将为您传递给它的每个具体类型专门化每个函数，从某种意义上说，会自动生成您正在考虑手动编写的所有那些专门化。所以添加类型注解的唯一原因是控制调用哪个方法:

is_this_a_number(x::Number) = true
is_this_a_number(x) = false

结构是另一回事。您可以在 Performance tips 中阅读有关结构中类型注释的更多信息。手册的部分。
最后，请记住，自该问题的早期以来，有些事情已经发生了变化。特别是 union splitting允许在许多情况下具有良好的性能 Union s 的具体类型(如果不确定，请使用 isconcretetype 检查每个)。

what does the N mean in the function's definition

数组中的维数。