added example with pmap on juliaset

Author: pevnak

docs/src/lecture_10/juliaset_p.jl

@@ -0,0 +1,39 @@
+using Plots, BenchmarkTools, Distributed
+function juliaset_pixel(z₀, c)
+    z = z₀
+    for i in 1:255
+        abs2(z)> 4.0 && return (i - 1)%UInt8
+        z = z*z + c
+    end
+    return UInt8(255)
+end
+
+function juliaset_column!(img, c, n, colj, j)
+    x = -2.0 + (j-1)*4.0/(n-1)
+    for i in 1:n
+        y = -2.0 + (i-1)*4.0/(n-1)
+        @inbounds img[i, colj] = juliaset_pixel(x+im*y, c)
+    end
+    nothing
+end
+
+function juliaset_range(c, n, columns)
+    img = Array{UInt8,2}(undef, n, length(columns))
+    for (colj, j) in enumerate(columns)
+        juliaset_column!(img, c, n, colj, j)
+    end
+    img
+end
+
+function juliaset_distributed(x, y, partitions = nworkers(), n = 1000)
+    c = x + y*im
+    columns = Iterators.partition(1:n, div(n, partitions))
+    slices = pmap(cols -> juliaset_range(c, n, cols), columns)
+    reduce(hcat, slices)
+end
+
+@btime juliaset_distributed(-0.79, 0.15)
+
+# frac = juliaset_distributed(-0.79, 0.15)
+# plot(heatmap(1:size(frac,1), 1:size(frac,2), frac, color=:Spectral))
+

docs/src/lecture_10/juliaset_t.jl

@@ -0,0 +1,77 @@
+using Plots, BenchmarkTools
+Threads.nthreads()
+function juliaset_pixel(z₀, c)
+    z = z₀
+    for i in 1:255
+        abs2(z)> 4.0 && return (i - 1)%UInt8
+        z = z*z + c
+    end
+    return UInt8(255)
+end
+
+function juliaset_column!(img, c, n, j)
+    x = -2.0 + (j-1)*4.0/(n-1)
+    for i in 1:n
+        y = -2.0 + (i-1)*4.0/(n-1)
+        @inbounds img[i,j] = juliaset_pixel(x+im*y, c)
+    end
+    nothing
+end
+
+function juliaset_single!(img, c, n)
+    for j in 1:n
+        juliaset_column!(img, c, n, j)
+    end
+    nothing
+end
+
+function juliaset(x, y, n=1000, method = juliaset_single!, extra...)
+    c = x + y*im
+    img = Array{UInt8,2}(undef,n,n)
+    method(img, c, n, extra...)
+    return img
+end
+
+# frac = juliaset(-0.79, 0.15)
+# plot(heatmap(1:size(frac,1),1:size(frac,2), frac, color=:Spectral))
+
+
+@btime juliaset(-0.79, 0.15);
+
+function juliaset_static!(img, c, n)
+    Threads.@threads for j in 1:n
+        juliaset_column!(img, c, n, j)
+    end
+    nothing
+end
+
+@btime juliaset(-0.79, 0.15, 1000, juliaset_static!);
+
+
+using Folds
+function juliaset_folds!(img, c, n)
+    Folds.foreach(j -> juliaset_column!(img, c, n, j), 1:n)
+    nothing
+end
+julia> @btime juliaset(-0.79, 0.15, 1000, juliaset_folds!);
+  16.267 ms (25 allocations: 978.20 KiB)
+
+function juliaset_folds!(img, c, n, nt)
+    parts = collect(Iterators.partition(1:n, cld(n, nt)))
+    Folds.foreach(parts) do ii
+        foreach(j ->juliaset_column!(img, c, n, j), ii)
+    end
+    nothing
+end
+julia> @btime juliaset(-0.79, 0.15, 1000, (args...) -> juliaset_folds!(args..., 16));
+  16.716 ms (25 allocations: 978.61 KiB)
+
+
+using FLoops, FoldsThreads
+function juliaset_folds!(img, c, n)
+    @floop ThreadedEx(basesize = 2) for j in 1:n
+        juliaset_column!(img, c, n, j)
+    end
+    nothing
+end
+@btime juliaset(-0.79, 0.15, 1000, juliaset_folds!);

docs/src/lecture_10/lecture.md

@@ -7,9 +7,33 @@ Julia offers different levels of parallel programming
 
 In this lecture, we will focus mainly on the first two, since SIMD instructions are mainly used for optimization of loops, and task switching is not a true paralelism, but allows to run a different task when one task is waiting for example for IO.
 
+## controller / worker model of parallel processes
+- the usual remote fetch call 
+- solve monte carlo
+- pmap
 
+- how to set up workers, 
+    + how to load functions, modules
+    + julia -p 16 -L load_my_script.jl
+- how to send data / how to define variable on remote process
+
+## Synchronization primitives 
+- Channels and their guarantees
+- How to orchestrate workers by channels
+- how to kill the remote process with channel
+
+## Sending data
+- Do not send `randn(1000, 1000)`
+- Serialization is very time consuming, an efficient converstion to something simple might be wort
+- Dict("a" => [1,2,3], "b" = [2,3,4,5]) -> (Array of elements, array of bounds, keys)
 
 ## Multi-Threadding 
+- Locks / lock-free multi-threadding
+- Show the effect of different schedullers
+- intra-model parallelism
+- sucks when operating with Heap
+
+## Julia sets
 An example adapted from [Eric Aubanel](http://www.cs.unb.ca/~aubanel/JuliaMultithreadingNotes.html).
 
 For ilustration, we will use Julia set fractals, ad they can be easily paralelized. Some fractals (Julia set, Mandelbrot) are determined by properties of some complex-valued functions. Julia set counts, how many iteration is required for  ``f(z)=z^2+c`` to be bigger than two in absolute value, ``|f(z)>=2``. The number of iterations can then be mapped to the pixel's color, which creates a nice visualization we know.
@@ -150,4 +174,13 @@ function juliaset_folds!(img, c, n)
 end
 julia> @btime juliaset(-0.79, 0.15, 1000, juliaset_folds!);
   10.421 ms (3582 allocations: 1.20 MiB)
-```
+```
+
+### Materials
+- http://cecileane.github.io/computingtools/pages/notes1209.html
+- https://lucris.lub.lu.se/ws/portalfiles/portal/61129522/julia_parallel.pdf
+- https://www.csd.uwo.ca/~mmorenom/cs2101a_moreno/Parallel_computing_with_Julia.pdf
+- Threads: https://juliahighperformance.com/code/Chapter09.html
+- Processes: https://juliahighperformance.com/code/Chapter10.html
+- Alan Adelman uses FLoops in https://www.youtube.com/watch?v=dczkYlOM2sg
+- Examples: ?Heat equation? from https://hpc.llnl.gov/training/tutorials/introduction-parallel-computing-tutorial#Examples