Julia，如何创建一个由几个可选宏组成的宏？

Question

在 Julia 中，我正在尝试不同的并行化库，以使我的程序性能更高，并检查 memory 消耗是否与没有并行化时相同。 不幸的是，这会导致大量重复。

有没有一种方法可以组织我的代码，以便我只编写一次算法，然后一些带有参数的宏决定代码的并行化方式？ 我的问题与这个类似。 例如，我的 MWE

using ThreadsX, Folds, FLoops, Polyester
create_data = (n,s) -> [rand(1:n,r) for j=1:n for r∈[rand(1:s)]]

function F!(method ::Int, L ::Vector{Vector{Int}}) ::Nothing
    n = length(L)
    if method==0                  for j=1:n sort!(L[j]) end end
    if method==1 Threads.@threads for j=1:n sort!(L[j]) end end
    if method==2 ThreadsX.foreach(1:n) do j sort!(L[j]) end end
    if method==3 Folds.foreach(1:n)    do j sort!(L[j]) end end
    if method==4 FLoops.@floop    for j=1:n sort!(L[j]) end end
    if method==5 Polyester.@batch for j=1:n sort!(L[j]) end end 
    return nothing end
for mtd=0:5
    L = create_data(10^6,10^3);   
    @time F!(mtd,L) end

回报

 17.967120 seconds
  4.537954 seconds (38 allocations: 3.219 KiB)
  4.418978 seconds (353 allocations: 27.875 KiB)
  5.583201 seconds (54 allocations: 3.875 KiB)
  5.542852 seconds (53 allocations: 3.844 KiB)
  4.263488 seconds (3 allocations: 80 bytes)

所以对于一个非常简单的问题已经有不同的表现。 在我的实际情况下，而不是sort!(L[j])我有很多密集的代码，有几个Array s， Vector{Vector} s， Dict s，......，不同的线程偶尔从同一个地方读取，但是写到不同的地方，在 memory 中分配空间，改变输入等。有没有办法创建一个新的宏@Parallel ，这样我的代码就可以了

function F!(method ::Int, L ::Vector{Vector{Int}}) ::Nothing
    n = length(L)
    @Parallel(method) for j=1:n sort!(L[j]) end
    return nothing end

请注意，我从未创建过宏，到目前为止我只使用过它们，因此欢迎提供一些解释。

Answer 1

基于宏的解决方案是可能的，但对我来说似乎没有必要。 我宁愿这样组织代码：

function testfun!(x::Vector{Int})
    # here goes the repetitive part
    return sort!(x)
end

# entry point for dispatch, and set up data
function F(kernel!, M, N, strategy::Symbol)
    L = create_data(M, N)
    return F!(kernel!, L, Val{strategy}())
end

# and a function to run the loop for every strategy
function F!(kernel!, L, ::Val{:baseline})
    n = length(L)
    for j=1:n kernel!(L[j]) end
end
function F!(kernel!, L, ::Val{:Threads})
    n = length(L)
    Threads.@threads for j=1:n kernel!(L[j]) end
end
function F!(kernel!, L, ::Val{:ThreadsX})
    n = length(L)
    ThreadsX.foreach(1:n) do j kernel!(L[j]) end 
end
# ...
# + rest of the loop functions for Floops, Folds, etc.

function dotests()
    for strategy = (:baseline, :Threads, :ThreadsX, ...)
        @benchmark F(testfun!, 10^6, 10^3, strategy) 
    end
end

这显示了一种基于调度的方法。 您同样可以使用字典或条件。 重要的一点是分离“跑步者” F! 来自“内核”function。