multiprocessing

Author: GiggleLiu

Project.toml

@@ -9,6 +9,7 @@ CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 Cairo = "159f3aea-2a34-519c-b102-8c37f9878175"
 Compose = "a81c6b42-2e10-5240-aca2-a61377ecd94b"
 DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
+Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

docs/src/performancetips.md

@@ -135,7 +135,44 @@ julia> lineplot(hamming_distribution(samples, samples))
           ⠀0⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀80⠀ 
 ```
 
-(To be written.)
+## Multiprocessing
+Submodule `GraphTensorNetworks.SimpleMutiprocessing` provides a function [`multiprocess_run`](@ref) function for simple multi-processing jobs.
+Suppose we want to find the independence polynomial for multiple graphs with 4 processes.
+We can create a file, e.g. named `run.jl` with the following content
+
+```julia
+using Distributed, GraphTensorNetworks.SimpleMultiprocessing
+using Random, GraphTensorNetworks  # to avoid multi-precompiling
+@everywhere using Random, GraphTensorNetworks
+
+results = multiprocess_run(collect(1:10)) do seed
+    Random.seed!(seed)
+    n = 10
+    @info "Graph size $n x $n, seed= $seed"
+    g = random_diagonal_coupled_graph(n, n, 0.8)
+    gp = Independence(g; optimizer=TreeSA(), simplifier=MergeGreedy())
+    res = solve(gp, GraphPolynomial())[]
+    return res
+end
+
+println(results)
+```
+
+One can run this script file with the following command
+```bash
+$ julia -p4 run.jl
+      From worker 3:	[ Info: running argument 4 on device 3
+      From worker 4:	[ Info: running argument 2 on device 4
+      From worker 5:	[ Info: running argument 3 on device 5
+      From worker 2:	[ Info: running argument 1 on device 2
+      From worker 3:	[ Info: Graph size 10 x 10, seed= 4
+      From worker 4:	[ Info: Graph size 10 x 10, seed= 2
+      From worker 5:	[ Info: Graph size 10 x 10, seed= 3
+      From worker 2:	[ Info: Graph size 10 x 10, seed= 1
+      From worker 4:	[ Info: running argument 5 on device
+      ...
+```
+You will see a vector of polynomials printed out.
 
 ## Make use of GPUs
 To upload the computing to GPU, you just add need to use CUDA, and offer a new key word argument.

docs/src/ref.md

@@ -137,6 +137,11 @@ random_square_lattice_graph
 
 One can also use `random_regular_graph` and `smallgraph` in [Graphs](https://github.com/JuliaGraphs/Graphs.jl) to build special graphs.
 
+#### Multiprocessing
+```@docs
+GraphTensorNetworks.SimpleMultiprocessing.multiprocess_run
+```
+
 #### Shortcuts
 ```@docs
 max_size

src/GraphTensorNetworks.jl

@@ -65,6 +65,7 @@ include("bounding.jl")
 include("visualize.jl")
 include("interfaces.jl")
 include("deprecate.jl")
+include("multiprocessing.jl")
 
 using Requires
 function __init__()

src/multiprocessing.jl

@@ -0,0 +1,54 @@
+module SimpleMultiprocessing
+using Distributed
+export multiprocess_run
+
+function do_work(f, jobs, results) # define work function everywhere
+    while true
+        job = take!(jobs)
+        @info "running argument $job on device $(Distributed.myid())"
+        res = f(job)
+        put!(results, res)
+    end
+end
+
+"""
+    multiprocess_run(func, inputs::AbstractVector)
+
+Execute function `func` on `inputs` with multiple processing.
+
+Example
+---------------------------
+Suppose we have a file `run.jl` with the following contents
+```julia
+using GraphTensorNetworks.SimpleMultiprocessing
+
+results = multiprocess_run(x->x^2, randn(8))
+```
+
+In an terminal, you may run the script with 4 processes by typing
+```bash
+\$ julia -p4 run.jl
+      From worker 2:	[ Info: running argument -0.17544008350172655 on device 2
+      From worker 5:	[ Info: running argument 0.34578117779452555 on device 5
+      From worker 3:	[ Info: running argument 2.0312551239727705 on device 3
+      From worker 4:	[ Info: running argument -0.7319353419291961 on device 4
+      From worker 2:	[ Info: running argument 0.013132180639054629 on device 2
+      From worker 3:	[ Info: running argument 0.9960101782201602 on device 3
+      From worker 4:	[ Info: running argument -0.5613942832743966 on device 4
+      From worker 5:	[ Info: running argument 0.39460402723831134 on device 5
+```
+"""
+function multiprocess_run(func, inputs::AbstractVector{T}) where T
+    n = length(inputs)
+    jobs = RemoteChannel(()->Channel{T}(n));
+    results = RemoteChannel(()->Channel{Any}(n));
+    for i in 1:n
+        put!(jobs, inputs[i])
+    end
+    for p in workers() # start tasks on the workers to process requests in parallel
+        remote_do(do_work, p, func, jobs, results)
+    end
+    return Any[take!(results) for i=1:n]
+end
+
+end

test/multiprocessing.jl

@@ -0,0 +1,6 @@
+using GraphTensorNetworks.SimpleMultiprocessing, Test
+
+@testset "multiprocessing" begin
+    results = multiprocess_run(x->x^2, collect(1:5))
+    @test results == [1, 2, 3, 4, 5] .^ 2
+end

test/runtests.jl

@@ -37,6 +37,10 @@ end
     include("visualize.jl")
 end
 
+@testset "multiprocessing" begin
+    include("multiprocessing.jl")
+end
+
 # --------------
 # doctests
 # --------------