手把手教你如何用Julia做GPU编程（附代码）

 1using CuArrays, FileIO, Colors, GPUArrays, BenchmarkTools
 2using CuArrays: CuArray
 3"""
 4The function calculating the Julia set
 5"""
 6function juliaset(z0, maxiter)
 7    c = ComplexF32(-0.5, 0.75)
 8    z = z0
 9    for i in 1:maxiter
10        abs2(z) > 4f0 && return (i - 1) % UInt8
11        z = z * z + c
12    end
13    return maxiter % UInt8 # % is used to convert without overflow check
14end
15range = 100:50:2^12
16cutimes, jltimes = Float64[], Float64[]
17function run_bench(in, out)
18  # use dot syntax to apply `juliaset` to each elemt of q_converted 
19  # and write the output to result
20  out .= juliaset.(in, 16)
21  # all calls to the GPU are scheduled asynchronous, 
22  # so we need to synchronize
23  GPUArrays.synchronize(out)
24end
25# store a reference to the last results for plotting
26last_jl, last_cu = nothing, nothing
27for N in range
28  w, h = N, N
29  q = [ComplexF32(r, i) for i=1:-(2.0/w):-1, r=-1.5:(3.0/h):1.5]
30  for (times, Typ) in ((cutimes, CuArray), (jltimes, Array))
31    # convert to Array or CuArray - moving the calculation to CPU/GPU
32    q_converted = Typ(q)
33    result = Typ(zeros(UInt8, size(q)))
34    for i in 1:10 # 5 samples per size
35      # benchmarking macro, all variables need to be prefixed with $
36      t = Base.@elapsed begin
37                run_bench(q_converted, result)
38      end
39      global last_jl, last_cu # we're in local scope
40      if result isa CuArray
41        last_cu = result
42      else
43          last_jl = result
44      end
45      push!(times, t)
46    end
47  end
48end
49
50cu_jl = hcat(Array(last_cu), last_jl)
51cmap = colormap("Blues", 16 + 1)
52color_lookup(val, cmap) = cmap[val + 1]
53save("results/juliaset.png", color_lookup.(cu_jl, (cmap,)))

1using Plots; plotly()
2x = repeat(range, inner = 10)
3speedup = jltimes ./ cutimes
4Plots.scatter(
5  log2.(x), [speedup, fill(1.0, length(speedup))], 
6  label = ["cuda" "cpu"], markersize = 2, markerstrokewidth = 0,
7  legend = :right, xlabel = "2^N", ylabel = "speedup"
8)

 1struct Test # an immutable struct
 2# that only contains other immutable, which makes 
 3# isbitstype(Test) == true
 4    x::Float32 
 5end
 6
 7# the isbits property is important, since those types can be used
 8# without constraints on the GPU!
 9@assert isbitstype(Test) == true
10x = (2, 2)
11isa(x, Tuple{Int, Int}) # tuples are also immutable
12mutable struct Test2 #-> mutable, isbits(Test2) == false
13    x::Float32
14end
15struct Test3
16    # contains a heap allocation/ reference, not isbits
17    x::Vector{Float32}
18    y::Test2 # Test2 is mutable and also heap allocated / a reference
19end
20Vector{Test} # <-  An Array with isbits elements is contigious in memory
21Vector{Test2} # <- An Array with mutable elements is basically an array of heap pointers. Since it just contains cpu heap pointers, it won't work on the GPU.

 1using CuArrays, LinearAlgebra
 2
 3# GPU Arrays can be constructed from all Julia arrays containing isbits types!
 4A1D = cu([1, 2, 3]) # cl for CLArrays
 5A1D = fill(CuArray{Int}, 0, (100,)) # CLArray for CLArrays
 6# Float32 array - Float32 is usually preferred and can be up to 30x faster on most GPUs than Float64
 7diagonal_matrix = CuArray{Float32}(I, 100, 100)
 8filled = fill(CuArray, 77f0, (4, 4, 4)) # 3D array filled with Float32 77
 9randy = rand(CuArray, Float32, 42, 42) # random numbers generated on the GPU
10# The array constructor also accepts isbits iterators with a known size
11# Note, that since you can also pass isbits types to a gpu kernel directly, in most cases you won't need to materialize them as an gpu array
12from_iter = CuArray(1:10)
13# let's create a point type to further illustrate what can be done:
14struct Point
15    x::Float32
16    y::Float32
17end
18Base.convert(::Type{Point}, x::NTuple{2, Any}) = Point(x[1], x[2])
19# because we defined the above convert from a tuple to a point
20# [Point(2, 2)] can be written as Point[(2,2)] since all array 
21# elements will get converted to Point
22custom_types = cu(Point[(1, 2), (4, 3), (2, 2)])
23typeof(custom_types)

1x = zeros(4, 4) # 4x4 array of zeros
2y = zeros(4) # 4 element array
3z = 2 # a scalar
4# y's 1st dimension gets repeated for the 2nd dimension in x
5# and the scalar z get's repeated for all dimensions
6# the below is equal to `broadcast(+, broadcast(+, xx, y), z)`
7x .+ y .+ z

 1using CuArrays
 2A = cu([1, 2, 3])
 3B = cu([1, 2, 3])
 4C = rand(CuArray, Float32, 3)
 5result = A .+ B .- C
 6test(a::T) where T = a * convert(T, 2) # convert to same type as `a`
 7
 8# inplace broadcast, writes directly into `result`
 9result .= test.(A) # custom function work
10
11# The cool thing is that this composes well with custom types and custom functions.
12# Let's go back to our Point type and define addition for it
13Base.:(+)(p1::Point, p2::Point) = Point(p1.x + p2.x, p1.y + p2.y)
14
15# now this works:
16custom_types = cu(Point[(1, 2), (4, 3), (2, 2)])
17
18# This particular example also shows the power of broadcasting: 
19# Non array types are broadcasted and repeated for the whole length
20result = custom_types .+ Ref(Point(2, 2))
21
22# So the above is equal to (minus all the allocations):
23# this allocates a new array on the gpu, which we can avoid with the above broadcast
24broadcasted = fill(CuArray, Point(2, 2), (3,))
25
26result == custom_types .+ broadcasted

 1using Flux, Flux.Data.MNIST, Statistics
 2using Flux: onehotbatch, onecold, crossentropy, throttle
 3using Base.Iterators: repeated, partition
 4using CuArrays
 5
 6# Classify MNIST digits with a convolutional network
 7
 8imgs = MNIST.images()
 9
10labels = onehotbatch(MNIST.labels(), 0:9)
11
12# Partition into batches of size 1,000
13train = [(cat(float.(imgs[i])..., dims = 4), labels[:,i])
14         for i in partition(1:60_000, 1000)]
15
16use_gpu = true # helper to easily switch between gpu/cpu
17
18todevice(x) = use_gpu ? gpu(x) : x
19
20train = todevice.(train)
21
22# Prepare test set (first 1,000 images)
23tX = cat(float.(MNIST.images(:test)[1:1000])..., dims = 4) |> todevice
24tY = onehotbatch(MNIST.labels(:test)[1:1000], 0:9) |> todevice
25
26m = Chain(
27  Conv((2,2), 1=>16, relu),
28  x -> maxpool(x, (2,2)),
29  Conv((2,2), 16=>8, relu),
30  x -> maxpool(x, (2,2)),
31  x -> reshape(x, :, size(x, 4)),
32  Dense(288, 10), softmax) |> todevice
33
34m(train[1][1])
35
36loss(x, y) = crossentropy(m(x), y)
37
38accuracy(x, y) = mean(onecold(m(x)) .== onecold(y))
39
40evalcb = throttle(() -> @show(accuracy(tX, tY)), 10)
41opt = ADAM(Flux.params(m));

1# train
2for i = 1:10
3    Flux.train!(loss, train, opt, cb = evalcb)
4end

1using Colors, FileIO, ImageShow
2N = 22
3img = tX[:, :, 1:1, N:N]
4println("Predicted: ", Flux.onecold(m(img)) .- 1)
5Gray.(collect(tX[:, :, 1, N]))

 1using GPUArrays, CuArrays
 2# Overloading the Julia Base map! function for GPUArrays
 3function Base.map!(f::Function, A::GPUArray, B::GPUArray)
 4    # our function that will run on the gpu
 5    function kernel(state, f, A, B)
 6        # If launch parameters aren't specified, linear_index gets the index
 7        # into the Array passed as second argument to gpu_call (`A`)
 8        i = linear_index(state)
 9            if i <= length(A)
10          @inbounds A[i] = f(B[i])
11        end
12        return
13    end
14    # call kernel on the gpu
15    gpu_call(kernel, A, (f, A, B))
16end

 1using BenchmarkTools
 2function threadded_map!(f::Function, A::Array, B::Array)
 3    Threads.@threads for i in 1:length(A)
 4        A[i] = f(B[i])
 5    end
 6  A
 7end
 8x, y = rand(10^7), rand(10^7)
 9kernel(y) = (y / 33f0) * (732.f0/y)
10# on the cpu without threads:
11single_t = @belapsed map!($kernel, $x, $y)
12
13# "on the CPU with 4 threads (2 real cores):
14thread_t = @belapsed threadded_map!($kernel, $x, $y)
15
16# on the GPU:
17xgpu, ygpu = cu(x), cu(y)
18gpu_t = @belapsed begin
19  map!($kernel, $xgpu, $ygpu)
20  GPUArrays.synchronize($xgpu)
21end
22times = [single_t, thread_t, gpu_t]
23speedup = maximum(times) ./ times
24println("speedup: $speedup")
25bar(["1 core", "2 cores", "gpu"], speedup, legend = false, fillcolor = :grey, ylabel = "speedup")

 1using CuArrays
 2
 3threads = (2, 2)
 4blocks = (2, 2)
 5T = fill(CuArray, (0, 0), (4, 4))
 6B = fill(CuArray, (0, 0), (4, 4))
 7gpu_call(T, (B, T), (blocks, threads)) do state, A, B
 8  # those names pretty much refer to the cuda names
 9    b = (blockidx_x(state), blockidx_y(state))
10    bdim = (blockdim_x(state), blockdim_y(state))
11    t = (threadidx_x(state), threadidx_y(state))
12    idx = (bdim .* (b .- 1)) .+ t
13    A[idx...] = b
14    B[idx...] = t
15    return
16end
17println("Threads index: \n", T)
18println("Block index: \n", B)