multithreading - 如何为这个简单的 Julia 代码获得接近最佳的并行效率？

Question

我有以下简单的代码:

function hamming4(bits1::Integer, bits2::Integer)
    return count_ones(bits1 ⊻ bits2)
end

function random_strings2(n, N)
    mask = UInt128(1) << n - 1
    return [rand(UInt128) & mask for i in 1:N]
end




function find_min(strings, n, N)
    minsofar = fill(n, Threads.nthreads())
    # minsofar = n
    Threads.@threads for i in 1:N 
    # for i in 1:N
        for j in i+1:N
            dist = hamming4(strings[i], strings[j])
            if dist < minsofar[Threads.threadid()]
                    minsofar[Threads.threadid()] = dist

            end
        end
    end
    return minimum(minsofar)
    #return minsofar
end


function ave_min(n, N)
    ITER = 10
    strings = random_strings2(n, N)
    new_min = find_min(strings, n, N)
    avesofar = new_min
    # print("New min ", new_min, ". New ave ", avesofar, "\n")
    total = avesofar
    for i in 1:ITER-1
        strings = random_strings2(n, N)
        new_min = find_min(strings, n, N)
        avesofar = avesofar*(i/(i+1)) + new_min/(i+1)
        print("Iteration ", i, ". New min ", new_min, ". New ave ", round(avesofar; digits=2), "\n")
    end
    return avesofar
end

N = 2^16
n = 99

print("Overall average ", ave_min(n, N), "\n")

当我在 Linux 的 AMD 8350 上运行它时，CPU 使用率约为 430%(而不是接近 800%)。

Is it possible to make the parallelisation work more efficiently?

另外，我注意到一个新的非常令人印象深刻的包，名为 LoopVectorization.jl .当我在计算时 the Hamming distance看起来像可矢量化的方式，是否也可以以这种方式加速代码？

Can the code be vectorized using LoopVectorization.jl?

(我对 Julia 完全陌生)

Answer 1

您的代码的并行化似乎是正确的。

您很可能在 Atom 或其他 IDE 中运行它。默认情况下，Atom 仅使用半个内核(更准确地说，仅使用物理内核而非逻辑内核)。

例如，在我的机器上以 Atom 运行:

julia> Threads.nthreads()
4

您需要做的是明确设置 JULIA_NUM_THREADS
Windows 命令行(仍然假设有 8 个逻辑核心)

set JULIA_NUM_THREADS=8

Linux 命令行

export JULIA_NUM_THREADS=8

这样做之后，您的代码将 100% 占用我所有的内核。

编辑

经过讨论 - 您可以使用 Distributed 将时间减少到单线程时间的 20% 左右。而不是 Threads因为这避免了内存共享:

代码看起来或多或少是这样的:

using Distributed
addprocs(8)

@everywhere function hamming4(bits1::Integer, bits2::Integer)
    return count_ones(bits1 ⊻ bits2)
end

function random_strings2(n, N)
    mask = UInt128(1) << n - 1
    return [rand(UInt128) & mask for i in 1:N]
end

function find_min(strings, n, N)
    return @distributed (min) for i in 1:N-1
        minimum(hamming4(strings[i], strings[j]) for j in i+1:N)
    end
end

### ... the rest of code remains unchanged