How is a parallel simple loop for the Julia language?
I already wrote serial code to solve Laplace's equation, but when I tried to write it in parallel in Julia, it takes more time and memory than serial code. I wrote a simple example of this. How can I parallel this code?
There is a domain t1
.
t2
will be computed and then t1 = t2
@everywhere function left!(t1,t2,n,l_type,b_left,dx=1.0,k=50.0)
if l_type==1
for i=1:n
t2[i,1]=(b_left*dx/k)+t1[i,2];
t1[i,1]=t2[i,1];
end
else
for i=1:n
t1[i,1]=b_left;
end
end
return t1 end
# parallel left does not work.
@everywhere function pleft!(t1,t2,n,l_type,b_left,dx=1.0,k=50.0)
if l_type==1
@parallel for i=1:n
t2[i,1]=(b_left*dx/k)+t1[i,2];
t1[i,1]=t2[i,1];
end
else
@parallel for i=1:n
t1[i,1]=b_left;
end
end
return t1
end
n = 10;
t1 = SharedArray(Float64,(n,n));
t2=t1;
typ = 0;
value = 10;
dx = 1;
k=50;
@time t3 = pleft!(t1,t2,n,typ,value,dx,k)
@time t2 = left!(t1,t2,n,typ,value,dx,k)
answer:
0.000872 seconds (665 allocations: 21.328 KB) # for parallel one
0.000004 seconds (4 allocations: 160 bytes) #for usual one
how can i fix this?
after calculating what i should calculate below in while loop. I need to execute parallel code below.
@everywhere function oneStepseri(t1,N)
t2 = t1;
for j = 2:(N-1)
for i = 2:(N-1)
t2[i,j]=0.25*(t1[i-1,j]+t1[i+1,j]+t1[i,j-1]+t1[i,j+1]);
end
end
return t2;
end
thank...
source to share
I've tried a lot. @parallel
with SharedArray
, Distributed Array
, and use of a domain division @spawn
. there was no acceleration. but Julia recently added " Threads
", you can add Threads by export JULIA_NUM_THREADS=4
in command window. using Threads.@threads
, you can use your code in parallel. check the number of threads on Threads.nthreads()
here is my code and it gives me a good speedup.
#to add threads export JULIA_NUM_THREADS=4
nth = Threads.nthreads(); #print number of threads
println(nth);
a = zeros(10);
Threads.@threads for i = 1:10
a[i] = Threads.threadid()
end
show(a)
b = zeros(100000);
c = zeros(100000);
b[1] = b[end] = 1;
c[1] = c[end] = 1;
function noth(A)
B = A;
for i=2:(length(A)-1)
B[i] = (A[i-1] + A[i+1])*0.5;
end
return B
end
function th(A)
B = A;
Threads.@threads for i=2:(length(A)-1)
B[i] = (A[i-1] + A[i+1])*0.5;
end
return B
end
println("warmup noth , th")
@time bb = noth(b)
@time cc = th(c)
println("end ")
@time bb = noth(b)
@time cc = th(c)
@time bb = noth(b)
@time cc = th(c)
@time bb = noth(b)
@time cc = th(c)
@time bb = noth(b)
@time cc = th(c)
@time bb = noth(b)
@time cc = th(c)
@time bb = noth(b)
@time cc = th(c)
show(bb[10])
println("\nbb ------------------------------------------------------------------------------------------------------------------> cc")
show(cc[10])
the answer is like this
5
[1.0,1.0,2.0,2.0,3.0,3.0,4.0,4.0,5.0,5.0]warmup noth , th
0.008661 seconds (2.53 k allocations: 113.180 KB)
0.020738 seconds (7.94 k allocations: 336.981 KB)
end
0.000446 seconds (4 allocations: 160 bytes)
0.000122 seconds (6 allocations: 224 bytes)
0.000437 seconds (4 allocations: 160 bytes)
0.000135 seconds (6 allocations: 224 bytes)
0.000435 seconds (4 allocations: 160 bytes)
0.000115 seconds (6 allocations: 224 bytes)
0.000447 seconds (4 allocations: 160 bytes)
0.000112 seconds (6 allocations: 224 bytes)
0.000440 seconds (4 allocations: 160 bytes)
0.000109 seconds (6 allocations: 224 bytes)
0.000439 seconds (4 allocations: 160 bytes)
0.000116 seconds (6 allocations: 224 bytes)
0.052478790283203125
bb ------------------------------------------------------------------------------------------------------------------> cc
0.052478790283203125juser@juliabox:~/threads$
for 5 threads and 100,000 nodes.
Note that there is no acceleration for warm-up. but after that there is an acceleration.
0.000446 seconds (4 allocations: 160 bytes) # usual code run
0.000122 seconds (6 allocations: 224 bytes) #parallel code run
source to share