remove sum, maximum, minimum to avoid ambigous error

Author: islent

.github/workflows/CI.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         version:
-          - '1.11.6'
+          - '1.12.4'
         os:
           - ubuntu-latest
           - macOS-latest

Project.toml

@@ -1,7 +1,7 @@
 name = "ParallelOperations"
 uuid = "09c1cff2-b94d-4c31-85a1-721512e21c63"
 authors = ["islent <leoislent@gmail.com>"]
-version = "0.1.2"
+version = "0.1.3"
 
 [deps]
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"

Readme.md

@@ -146,11 +146,8 @@ scatterto(workers(), a, :b, Main)
 ```julia
 @everywhere workers() x = 1.0
 
-sum(workers(), :x)
 allsum(workers(), :x)
-maximum(workers(), :x)
 allmaximum(workers(), :x)
-minimum(workers(), :x)
 allminimum(workers(), :x)
 ```
 

src/ParallelOperations.jl

@@ -2,7 +2,7 @@ module ParallelOperations
 
 using Distributed
 
-import Base: reduce, sum, maximum, minimum
+import Base: reduce
 
 export
     sendto, @sendto,
@@ -17,19 +17,24 @@ export
     allgather,
     allreduce,
 
-    sum, allsum,
-    maximum, allmaximum,
-    minimum, allminimum
+    allsum,
+    allmaximum,
+    allminimum
 
 # point-to-point
 
 function sendto(p::Int, expr, data, mod::Module = Main)
-    @async @spawnat(p, Core.eval(mod, Expr(:(=), expr, data)))
+    remotecall_fetch(p) do
+        Core.eval(mod, Expr(:(=), expr, data))
+    end
 end
 
 function sendto(p::Int, mod::Module = Main; args...)
-    data = Dict(nm => val for (nm, val) in args)
-    @async @spawnat(p, Core.eval(mod, Expr(:(=), :parallel_data, data)))
+    for (nm, val) in args
+        remotecall_fetch(p) do
+            Core.eval(mod, Expr(:(=), nm, val))
+        end
+    end
 end
 
 function sendto(p::Int, f::Function, expr, mod::Module = Main; args = ())
@@ -61,7 +66,9 @@ macro sendto(p, expr, mod::Symbol = :Main)
 end
 
 function getfrom(p::Int, expr, mod::Module = Main)
-    return fetch(@spawnat(p, Core.eval(mod, expr)))
+    return remotecall_fetch(p) do
+        Core.eval(mod, expr)
+    end
 end
 
 macro getfrom(p, obj, mod::Symbol = :Main)
@@ -92,13 +99,13 @@ end
 
 function bcast(pids::Array, f::Function, expr, mod::Module = Main; args...)
     @sync for p in pids
-        @async sendto(p, f, expr, mod; args...)
+        sendto(p, f, expr, mod; args...)
     end
 end
 
 function bcast(pids::Array, f::Function, mod::Module = Main; args...)
     @sync for p in pids
-        @async sendto(p, f, mod; args...)
+        sendto(p, f, mod; args...)
     end
 end
 
@@ -166,13 +173,22 @@ function allreduce(f::Function, pids::Array, src_expr, target_expr = src_expr, m
 end
 
 # Commonly used functions
-sum(pids::Array, expr::Union{Symbol, Expr}, mod::Module = Main) = sum(gather(pids, expr, mod))
-allsum(pids::Array, src_expr::Union{Symbol, Expr}, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, sum(pids, src_expr, mod), mod)
+function _allsum(pids::Array, expr::Union{Symbol, Expr}, mod::Module = Main)
+    return Base.sum(gather(pids, expr, mod))
+end
 
-maximum(pids::Array, expr, mod::Module = Main) = maximum(gather(pids, expr, mod))
-allmaximum(pids::Array, src_expr, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, maximum(pids, src_expr, mod), mod)
+allsum(pids::Array, src_expr::Union{Symbol, Expr}, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, _allsum(pids, src_expr, mod), mod)
+
+function _allmaximum(pids::Array, expr, mod::Module = Main)
+    return Base.maximum(gather(pids, expr, mod))
+end
+
+allmaximum(pids::Array, src_expr, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, _allmaximum(pids, src_expr, mod), mod)
+
+function _allminimum(pids::Array, expr, mod::Module = Main)
+    return Base.minimum(gather(pids, expr, mod))
+end
 
-minimum(pids::Array, expr, mod::Module = Main) = minimum(gather(pids, expr, mod))
-allminimum(pids::Array, src_expr, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, minimum(pids, src_expr, mod), mod)
+allminimum(pids::Array, src_expr, target_expr = src_expr, mod::Module = Main) = bcast(pids, target_expr, _allminimum(pids, src_expr, mod), mod)
 
 end

test/runtests.jl

@@ -140,37 +140,36 @@ end
     # sum
     @everywhere pids x = myid()
     allsum(pids, :x, :y)
+    @test getfrom(pids[1], :y) == sum(pids)
+
     allsum(pids, :x)
-    @test sum(pids, :x) == 4 * sum(pids)
-    @test sum(pids, :y) == 4 * sum(pids)
+    @test getfrom(pids[1], :x) == sum(pids)
 
     # maximum
     @everywhere pids x = myid()
-    @test maximum(pids, :x) == maximum(pids)
 
     allmaximum(pids, :x, :y)
-    @test sum(pids, :y) == 4 * maximum(pids)
+    @test getfrom(pids[1], :y) == maximum(pids)
 
     allmaximum(pids, :x)
-    @test sum(pids, :x) == 4 * maximum(pids)
+    @test getfrom(pids[1], :x) == maximum(pids)
 
     # minimum
     @everywhere pids x = myid()
-    @test minimum(pids, :x) == minimum(pids)
 
     allminimum(pids, :x, :y)
-    @test sum(pids, :y) == 4 * minimum(pids)
+    @test getfrom(pids[1], :y) == minimum(pids)
 
     allminimum(pids, :x)
-    @test sum(pids, :x) == 4 * minimum(pids)
+    @test getfrom(pids[1], :x) == minimum(pids)
 end
 
 @everywhere fun() = 123
 @everywhere fun2() = 4
 
 @testset "function" begin
-    sendto(2, fun)
-    @test getfrom(2, :(fun())) == 123
+    sendto(pids[1], fun)
+    @test getfrom(pids[1], :(fun())) == 123
 
     bcast(pids, fun2)
     @test sum(gather(pids, :(fun2()))) == 16