using Printf
function answer_checker(answer,solution)
    if answer == solution
        "🥳 Well done! "
    else
        "It's not correct. Keep trying! 💪"
    end |> println
end
q_1_check(answer) = answer_checker(answer,"a")
q_2_check(answer) = answer_checker(answer,"b")
function why_q1()
    msg = """
    We send the matrix (16 entries) and then we receive back the result (1 extra integer). Thus, the total number of transferred integers in 17.
    """
    println(msg)
end
function why_q2()
    msg = """
    Even though we only use a single entry of the matrix in the remote worker, the entire matrix is captured and sent to the worker. Thus, we will transfer 17 integers like in Question 1.
    """
    println(msg)
end
function why_q3()
    msg = """
    The value of x will still be zero since the worker receives a copy of the matrix and it modifies this copy, not the original one.
    """
    println(msg)
end
function why_q4()
    msg = """
    In this case, the code a[2]=2 is executed in the main process. Since the matrix is already in the main process, it is not needed to create and send a copy of it. Thus, the code modifies the original matrix and the value of x will be 2.
    """
    println(msg)
end
println("🥳 Well done! ")

using Distributed

addprocs(3)

procs()

workers()

nprocs()

nworkers()

myid()

@everywhere println(myid())

using Distributed
machines = [("user@server1",3),("user@server2",4)]
addprocs(machines)

using Distributed
using ClusterManagers
addprocs(SlurmManager(128), partition="debug", t="00:5:00")

a = ones(2,3)

proc = 2
ftr = remotecall(ones,proc,2,3)

fetch(ftr)

fun = (m,n) -> (sleep(10); ones(m,n))

proc = 2
ftr = remotecall(fun,proc,2,3)

1+1

fetch(ftr)

@spawnat proc ones(2,3)

fun = () -> ones(2,3)
remotecall(fun,proc)

tsk = @async begin
    sleep(3)
    zeros(2)
end
fetch(tsk)

ftr = @spawnat :any begin
    sleep(3)
    zeros(2)
end
fetch(ftr)

a = @fetchfrom proc begin
    sleep(3)
    zeros(2)
end

proc = 4
a = rand(10,10)
b = rand(10,10)
ftr = remotecall(+,proc,a,b) # Send
fetch(ftr); # Receive

proc = 4
a = rand(10,10)
b = rand(10,10)
fun = () -> a+b
ftr = remotecall(fun,proc) # Send
fetch(ftr); # Receive

fun = ()->Channel{Int}()
chnl = RemoteChannel(fun)

@spawnat 4 begin
    for i in 1:5
        put!(chnl,i)
    end
    close(chnl)
end;

take!(chnl)

chnl = Channel{Int}()
@spawnat 4 begin
    for i in 1:5
        put!(chnl,i)
    end
    close(chnl)
end
take!(chnl)

buffer_size = 2
owner = 3
fun = ()->Channel{Int}(buffer_size)
chnl = RemoteChannel(fun,owner)

@spawnat 4 begin
    println("start")
    for i in 1:5
        put!(chnl,i)
        println("I have put $i")
    end
    close(chnl)
    println("stop")
end;

take!(chnl)

fun = ()->Channel{Int}()
chnl = RemoteChannel(fun)

@spawnat 4 begin
    for i in 1:5
        put!(chnl,i)
    end
    close(chnl)
end;

for j in chnl
    @show j
end

while true
    try
        j = take!(chnl)
        @show j
    catch
        break
    end
end

a = rand(Int,4,4)
proc = 4
@fetchfrom proc sum(a^2)

answer = "x" #Replace x with a, b, c, or d
q_1_check(answer)

why_q1()

a = rand(Int,4,4)
proc = 4
@fetchfrom proc sum(a[2,2]^2)

answer = "x" #Replace x with a, b, c, or d
q_2_check(answer)

why_q2()

a = zeros(Int,3)
proc = 3
@sync @spawnat proc a[2] = 2
x = a[2]
x

why_q3()

a = zeros(Int,3)
proc = myid()
@sync @spawnat proc a[2] = 2
x = a[2]
x

why_q4()

function sleep_ones(m,n)
    sleep(4)
    ones(m,n)
end

proc = 3
remotecall_fetch(sleep_ones,proc,3,4)

@everywhere function sleep_ones(m,n)
    sleep(4)
    ones(m,n)
end

proc = 3
remotecall_fetch(sleep_ones,proc,3,4)

fun = (m,n) -> (sleep(4);ones(m,n))

proc = 3
remotecall_fetch(fun,proc,3,4)

using LinearAlgebra

@fetchfrom 3 norm([1,2,3])

@everywhere using LinearAlgebra

@fetchfrom 3 norm([1,2,3])

] activate .

@everywhere using Pkg

@spawnat 2 Pkg.status();

@everywhere Pkg.activate(".")

@spawnat 2 Pkg.status();

function compute_π(n)
    s = 1.0
    for i in 1:n
        s += (isodd(i) ? -1 : 1) / (i*2+1)
    end
    4*s
end

function compute_π_dist(n)
    s = 1.0
    r = @distributed (+) for  i in 1:n
        (isodd(i) ? -1 : 1) / (i*2+1)
    end
    4*(s+r)
end

@time compute_π(4_000_000_000)

@time compute_π_dist(4_000_000_000)

a = [ rand(300,300) for i in 1:60];

using LinearAlgebra

@time svd.(a);

@time pmap(svd,a);

Programming large-scale parallel systems¶

Distributed computing in Julia¶

Contents¶

How to create Julia processes¶

Adding processes locally¶

Each process runs a separated Julia instance¶

Basic info about processes¶

Creating workers in other machines¶

Adding workers with ClusterManagers.jl¶

Executing code remotely¶

Function `remotecall`¶

`remotecall` is asynchronous¶

Useful macro: `@spawnat`¶

`@async` vs `@spawnat`¶

Another useful macro: `@fetchfrom`¶

Data movement¶

Explicit data movement in `remotecall` / `fetch`¶

Implicit data movement¶

Data movement with remote channels¶

This will not work!¶

Remote channels can be buffered¶

Remote channels are also iterable¶

Questions¶

Remember: each process runs in a separated Julia instance¶

Functions are defined in a single process¶

Anonymous functions are available everywhere¶

Each proc uses packages independently¶

Each process has its own active package environment¶

Easy ways of parallelizing code¶

Useful macro: @distributed¶

Useful function: `pmap`¶

Summary¶

Exercises¶

Exercise 1¶

License¶

Programming large-scale parallel systems¶

Distributed computing in Julia¶

Contents¶

How to create Julia processes¶

Adding processes locally¶

Each process runs a separated Julia instance¶

Basic info about processes¶

Creating workers in other machines¶

Adding workers with ClusterManagers.jl¶

Executing code remotely¶

Function remotecall¶

remotecall is asynchronous¶

Useful macro: @spawnat¶

@async vs @spawnat¶

Another useful macro: @fetchfrom¶

Data movement¶

Explicit data movement in remotecall / fetch¶

Implicit data movement¶

Data movement with remote channels¶

This will not work!¶

Remote channels can be buffered¶

Remote channels are also iterable¶

Questions¶

Remember: each process runs in a separated Julia instance¶

Functions are defined in a single process¶

Anonymous functions are available everywhere¶

Each proc uses packages independently¶

Each process has its own active package environment¶

Easy ways of parallelizing code¶

Useful macro: @distributed¶

Useful function: pmap¶

Summary¶

Exercises¶

Exercise 1¶

License¶

Function `remotecall`¶

`remotecall` is asynchronous¶

Useful macro: `@spawnat`¶

`@async` vs `@spawnat`¶

Another useful macro: `@fetchfrom`¶

Explicit data movement in `remotecall` / `fetch`¶

Useful function: `pmap`¶