Adding a few more examples (#12)

adding simple mat mult and return kernels

Author: leios

examples/matmul.jl

@@ -0,0 +1,67 @@
+using KernelAbstractions, Test, CUDAapi
+if CUDAapi.has_cuda_gpu()
+    using CuArrays
+    CuArrays.allowscalar(false)
+end
+
+# Simple kernel for matrix multiplication
+@kernel function matmul!(a, b, c)
+    if size(a)[2] != size(b)[1]
+        # here, we need a CPU / GPU generic print statement, like...
+        # CUDAnative.@cuprintf("Matrix size mismatch!")
+        return nothing
+    end
+    cI = @index(Global, Cartesian)
+
+    # creating a temporary sum variable for matrix multiplication
+    tmp_sum = 0
+
+    for i = 1:size(a)[2]
+        tmp_sum += a[cI[1],i] * b[i,cI[2]]
+    end
+
+    c[cI] = tmp_sum
+end
+
+# Creating a wrapper kernel for launching with error checks
+function launch_matmul!(a, b, c)
+    if size(a)[2] != size(b)[1]
+        println("Matrix size mismatch!")
+        return nothing
+    end
+    if isa(a, Array)
+        kernel! = matmul!(CPU(),4)
+    else
+        kernel! = matmul!(CUDA(),256)
+    end
+    kernel!(a, b, c, ndrange=size(c)) 
+end
+
+function check()
+    a = rand(256,123)
+    b = rand(123, 45)
+    c = zeros(256, 45)
+
+    # beginning CPU tests, returns event
+    ev = launch_matmul!(a,b,c)
+    wait(ev)
+
+    println("Testing CPU matrix multiplication...")
+    @test isapprox(a*b, c)
+
+    # beginning GPU tests
+    if has_cuda_gpu()
+        d_a = CuArray(a)
+        d_b = CuArray(b)
+        d_c = CuArray(c)
+
+        ev = launch_matmul!(d_a, d_b, d_c)
+        wait(ev)
+        c = a*b
+
+        println("Testing GPU matrix multiplication...")
+        @test isapprox(Array(d_c), c)
+    end
+end
+
+check()

examples/naive_transpose.jl

@@ -0,0 +1,88 @@
+using KernelAbstractions, Test, CUDAapi
+if CUDAapi.has_cuda_gpu()
+    using CuArrays
+    CuArrays.allowscalar(false)
+end
+
+@kernel function copy!(a,b)
+    I = @index(Global)
+    @inbounds b[I] = a[I]
+end
+
+@kernel function naive_transpose!(a, b)
+  I = @index(Global, Cartesian)
+  i, j = Tuple(I)
+  @inbounds b[i, j] = a[j, i]
+end
+
+# creating wrapper functions
+function launch_copy!(a, b)
+    if size(a) != size(b)
+        println("Matrix size mismatch!")
+        return nothing
+    end
+    if isa(a, Array)
+        kernel! = copy!(CPU(),4)
+    else
+        kernel! = copy!(CUDA(),1024)
+    end
+    kernel!(a, b, ndrange=size(a))
+end
+
+# creating wrapper functions
+function launch_naive_transpose!(a, b)
+    if size(a)[1] != size(b)[2] || size(a)[2] != size(b)[1]
+        println("Matrix size mismatch!")
+        return nothing
+    end
+    if isa(a, Array)
+        kernel! = naive_transpose!(CPU(),4)
+    else
+        kernel! = naive_transpose!(CUDA(),256)
+    end
+    kernel!(a, b, ndrange=size(a))
+end
+
+function main()
+
+    # resolution of grid will be res*res
+    res = 1024
+
+    # creating initial arrays on CPU and GPU
+    a = round.(rand(Float32, (res, res))*100)
+    b = zeros(Float32, res, res)
+
+    # beginning CPU tests
+    ev = launch_copy!(a, b)
+    wait(ev)
+
+    ev = launch_naive_transpose!(a,b)
+    wait(ev)
+
+    println("CPU transpose time is:")
+    println("Testing CPU transpose...")
+    @test a == transpose(b)
+
+    # beginning GPU tests
+    if has_cuda_gpu()
+        d_a = CuArray(a)
+        d_b = CuArray(zeros(Float32, res, res))
+
+        ev = launch_copy!(d_a, d_b)
+        wait(ev)
+
+        ev = launch_naive_transpose!(d_a, d_b)
+        wait(ev)
+
+        a = Array(d_a)
+        b = Array(d_b)
+
+        println("Testing GPU transpose...")
+        @test a == transpose(b)
+    end
+
+    return nothing
+end
+
+main()
+