Bump to AcceleratedKernels v0.3.0

Author: anicusan

.gitignore

@@ -22,3 +22,8 @@ docs/site/
 # committed for packages, but should be committed for applications that require a static
 # environment.
 Manifest.toml
+
+# Files generated while profiling
+*.log
+*.pb.gz
+*.obj

Project.toml

@@ -1,7 +1,7 @@
 name = "ImplicitBVH"
 uuid = "932a18dc-bb55-4cd5-bdd6-1368ec9cea29"
 authors = ["Andrei Leonard Nicusan <[email protected]> and contributors"]
-version = "0.5.1"
+version = "0.5.2"
 
 [deps]
 AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1"
@@ -13,7 +13,7 @@ KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
-AcceleratedKernels = "0.2"
+AcceleratedKernels = "0.3"
 ArgCheck = "2"
 Atomix = "0.1, 1"
 DocStringExtensions = "0.9"

prototype/Project.toml

@@ -2,10 +2,10 @@
 AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1"
 Atomix = "a9b6321e-bd34-4604-b9c9-b65b8de01458"
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
-CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f"
 ImplicitBVH = "932a18dc-bb55-4cd5-bdd6-1368ec9cea29"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
+Metal = "dde4c033-4e86-420c-a63e-0dd931031962"
 PProf = "e4faabce-9ead-11e9-39d9-4379958e3056"
 Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588"
 Revise = "295af30f-e4ad-537b-8983-00126c2a3abe"

prototype/interacting_particles.jl

@@ -0,0 +1,61 @@
+using ImplicitBVH
+using ImplicitBVH: BBox, BSphere
+import AcceleratedKernels as AK
+
+using Profile
+using PProf
+
+using Metal
+# using AtomixMetal
+
+using Random
+Random.seed!(0)
+
+
+function get_interacting_pairs(particle_centers::AbstractMatrix, cutoff::AbstractFloat)
+
+    # Construct bounding sphere around each particle of `cutoff` radius
+    num_particles = size(particle_centers, 2)
+    bounding_volumes = similar(particle_centers, BSphere{Float32}, num_particles)
+    AK.foreachindex(bounding_volumes) do i
+        bounding_volumes[i] = BSphere{Float32}(
+            (particle_centers[1, i], particle_centers[2, i], particle_centers[3, i]),
+            cutoff,
+        )
+    end
+
+    # Construct BVH, merging BSpheres into BBoxes, and using 32-bit Morton indices
+    bvh = BVH(bounding_volumes, BBox{Float32}, UInt32, default_start_level(num_particles))
+
+    # Traverse BVH - this returns a BVHTraversal
+    contacting_pairs = traverse(bvh)
+
+    # Return Vector{Tuple{Int32, Int32}} of particle index pairs
+    contacting_pairs.contacts
+end
+
+
+particle_centers = rand(Float32, 3, 12_486)
+# particle_centers = MtlArray(particle_centers)
+interacting_pairs = get_interacting_pairs(particle_centers, 0.0312f0)
+
+
+
+
+# Collect an allocation profile
+Profile.Allocs.clear()
+Profile.Allocs.@profile get_interacting_pairs(particle_centers, 0.0312f0)
+PProf.Allocs.pprof()
+
+
+
+# Example output: 
+#   julia> @show interacting_pairs
+#   interacting_pairs = Tuple{Int32, Int32}[(369, 667), (427, 974), ...]
+
+
+# using BenchmarkTools
+# @benchmark get_interacting_pairs(particle_centers, 0.0312f0)
+
+
+

prototype/mtl_test.jl

@@ -0,0 +1,34 @@
+using KernelAbstractions
+using Atomix: @atomic
+using Metal
+
+
+@kernel cpu=false inbounds=true function _traverse_nodes_gpu!(
+    dst, level,
+)
+    @atomic dst[level] += 1
+    
+    ithread = @index(Local, Linear)
+
+    if typeof(ithread) === Int32
+        dst[1] = 1
+    elseif typeof(ithread) === Int64
+        dst[1] = 2
+    elseif typeof(ithread) === UInt32
+        dst[1] = 3
+    else
+        dst[1] = sizeof(ithread)
+    end
+
+    @synchronize()
+end
+
+
+dst = MtlArray{UInt32}([0,0,0])
+level = 2
+
+kernel = _traverse_nodes_gpu!(get_backend(dst), 128)
+kernel(dst, level, ndrange=length(dst))
+KernelAbstractions.synchronize(get_backend(dst))
+
+

src/morton.jl

@@ -150,6 +150,7 @@ function _compute_extrema(bounding_volumes::AbstractGPUVector, options)
         min_centers,        # Reduce to the 3D minimum
         bounding_volumes,
         init=(floatmax(T), floatmax(T), floatmax(T)),
+        neutral=(floatmax(T), floatmax(T), floatmax(T)),
         block_size=options.block_size,
     )
 
@@ -158,6 +159,7 @@ function _compute_extrema(bounding_volumes::AbstractGPUVector, options)
         max_centers,
         bounding_volumes,
         init=(floatmin(T), floatmin(T), floatmin(T)),
+        neutral=(floatmin(T), floatmin(T), floatmin(T)),
         block_size=options.block_size,
     )
 

src/traverse/traverse_pair.jl

@@ -88,7 +88,7 @@ function traverse(
     extra = if bvtt1 isa AbstractGPUVector
         # For GPUs we need an additional global offset to coordinate writing results
         backend = get_backend(bvtt1)
-        KernelAbstractions.zeros(backend, index_type, bvh1.tree.levels * bvh2.tree.levels)
+        KernelAbstractions.zeros(backend, index_type, Int(bvh1.tree.levels * bvh2.tree.levels))
     else
         # For CPUs we need a vector of spawned tasks and a contact counter for each task
         tasks = Vector{Task}(undef, options.num_threads)

src/traverse/traverse_single.jl

@@ -149,7 +149,7 @@ function fill_initial_bvtt_single!(bvtt1, num_levels, start_level, level_nodes,
     if backend isa GPU
 
         # Convert linear index k to upper triangular (i, j) indices for a matrix of side n; 0-index
-        @fastmath function tri_ij(n::I, k::I) where I <: Integer
+        function tri_ij(n::I, k::I) where I <: Integer
             a = Float32(-8 * k + 4 * n * (n - 1) - 7)
             b = unsafe_trunc(I, sqrt(a) / 2.0f0 - 0.5f0)
             i = n - 2 - b

test/gputests.jl

@@ -21,6 +21,21 @@ function array_from_host(h_arr::AbstractArray, dtype=nothing)
 end
 
 
+@testset "mortons_gpu_$(backend)" begin
+    # This tests BV bounds computation too
+    Random.seed!(42)
+    for num_entities in 1:200
+        bvs = map(BSphere{Float32}, [6 * rand(3) .+ rand(3, 3) for _ in 1:num_entities])
+        bvs_gpu = array_from_host(bvs)
+
+        mortons = ImplicitBVH.morton_encode(bvs)
+        mortons_gpu = ImplicitBVH.morton_encode(bvs_gpu)
+
+        @test all(mortons .== Array(mortons_gpu))
+    end
+end
+
+
 @testset "bvh_gpu_$(backend)_single_randomised" begin
     # Random bounding volumes of different densities; BSphere leaves, BSphere nodes
     Random.seed!(42)

test/runtests.jl

@@ -333,7 +333,6 @@ end
     point = [0., 0., 0.]
     direction = [0., 0., -1.]
     @test isintersection(sphere, point, direction) == true
-
 end
 
 
@@ -693,6 +692,8 @@ end
 end
 
 
+
+
 @testset "bvh_single_randomised" begin
     # Random bounding volumes of different densities; BSphere leaves, BSphere nodes
     Random.seed!(42)