Updated CUDA version and compatible calls

src/Dirac/Dirac.jl

@@ -64,7 +64,7 @@ end
 
 function krnl_Dw!(so, U, si, m0, th, lp::SpaceParm{4,6,B,D}) where {B,D}
 
-    b, r = assign_thx()
+    b = Int64(CUDA.threadIdx().x);  r = Int64(CUDA.blockIdx().x)
 
     # For SF:
     #  - cttilde affects mass term at x0 = a, T-a
@@ -85,7 +85,7 @@ end
 
 function krnl_g5Dw!(so, U, si, m0, th, lp::SpaceParm{4,6,B,D}) where {B,D}
 
-    b, r = assign_thx()
+    b = Int64(CUDA.threadIdx().x);  r = Int64(CUDA.blockIdx().x)
 
     @inbounds begin 
         so[b,r] = (4+m0)*si[b,r]

src/LatticeGPU.jl

@@ -23,7 +23,7 @@ include("Space/Space.jl")
 
 using .Space
 export SpaceParm
-export up, dw, updw, point_coord, point_index, point_time, assign_thx
+export up, dw, updw, point_coord, point_index, point_time
 export BC_PERIODIC, BC_OPEN, BC_SF_AFWB, BC_SF_ORBI
 
 include("Fields/Fields.jl")

src/Space/Space.jl

@@ -334,9 +334,7 @@ Returns the sum of the cartesian coordinates of the point p=(b,r).
 end
 
 
-@inline assign_thx() = convert(Int64, CUDA.threadIdx().x), convert(Int64, CUDA.blockIdx().x)
+export up, dw, updw, point_index, point_coord, point_time
-
-export up, dw, updw, point_index, point_coord, point_time, assign_thx
 export BC_PERIODIC, BC_OPEN, BC_SF_AFWB, BC_SF_ORBI
 
 end

src/YM/YMact.jl

@@ -11,13 +11,15 @@
 
 function krnl_impr!(plx, U::AbstractArray{T}, c0, c1, Ubnd::NTuple{NB,T}, cG, ztw, lp::SpaceParm{N,M,B,D}) where {T,NB,N,M,B,D}
 
-    b, r = assign_thx()
+    b = Int64(CUDA.threadIdx().x)
+    r = Int64(CUDA.blockIdx().x)
     it = point_time((b, r), lp)
     
     Ush = @cuStaticSharedMem(T, (D,2))
     
     ipl = 0
     S = zero(eltype(plx))
+    @inbounds begin
         for id1 in N:-1:1
             bu1, ru1 = up((b, r), id1, lp)
             SFBC  = ((B == BC_SF_AFWB) || (B == BC_SF_ORBI) ) && (id1==N) 
@@ -115,13 +117,17 @@ function krnl_impr!(plx, U::AbstractArray{T}, c0, c1, Ubnd::NTuple{NB,T}, cG, zt
         
         I = point_coord((b,r), lp)
         plx[I] = S
+    end
         
     return nothing
 end
 
 function krnl_plaq!(plx, U::AbstractArray{T}, Ubnd, cG, ztw, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
 
-    b, r = assign_thx()
+    
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         it = point_time((b, r), lp)
 
         Ush = @cuStaticSharedMem(T, (D,2))
@@ -166,13 +172,15 @@ function krnl_plaq!(plx, U::AbstractArray{T}, Ubnd, cG, ztw, lp::SpaceParm{N,M,B
         
         I = point_coord((b,r), lp)
         plx[I] = S
+    end
     
     return nothing
 end
 
 function krnl_force_wilson_pln!(frc1, frc2, U::AbstractArray{T}, Ubnd, cG, ztw, ipl, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
 
-    b, r = assign_thx()
+    b = Int64(CUDA.threadIdx().x)
+    r = Int64(CUDA.blockIdx().x)
     it = point_time((b,r), lp)
     
     Ush = @cuStaticSharedMem(T, (D,2))
@@ -233,7 +241,8 @@ end
 
 function krnl_force_impr_pln!(frc1, frc2, U::AbstractArray{T}, c0, c1, Ubnd, cG, ztw, ipl, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
 
-    b, r = assign_thx()
+    b = Int64(CUDA.threadIdx().x)
+    r = Int64(CUDA.blockIdx().x)
     it = point_time((b, r), lp)
     
     Ush = @cuStaticSharedMem(T, (D,2))

src/YM/YMfields.jl

@@ -36,18 +36,24 @@ end
 
 function krnl_assign_SU3!(frc::AbstractArray{T}, m, lp::SpaceParm{N,M,BC_PERIODIC,D}) where {T,N,M,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         for id in 1:lp.ndim
             frc[b,id,r] = SU3alg(m[b,id,1,r], m[b,id,2,r], m[b,id,3,r],
                                  m[b,id,4,r], m[b,id,5,r], m[b,id,6,r],
                                  m[b,id,7,r], m[b,id,8,r])
         end
+    end
+    
     return nothing
 end
 
 function krnl_assign_SU3!(frc::AbstractArray{T}, m, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         it = point_time((b,r), lp)
 
         if ((B==BC_SF_AFWB)||(B==BC_SF_ORBI))
@@ -66,15 +72,20 @@ function krnl_assign_SU3!(frc::AbstractArray{T}, m, lp::SpaceParm{N,M,B,D}) wher
                 end
             end
         end
+    end
         
     return nothing
 end
 
 function krnl_assign_SU2!(frc, m, lp::SpaceParm{N,M,BC_PERIODIC,D}) where {N,M,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         for id in 1:lp.ndim
             frc[b,id,r] = SU2alg(m[b,id,1,r], m[b,id,2,r], m[b,id,3,r])
         end
+    end
+    
     return nothing
 end

src/YM/YMflow.jl

@@ -89,7 +89,9 @@ end
 
 function krnl_add_zth!(frc, frc2::AbstractArray{TA}, U::AbstractArray{TG}, lp::SpaceParm{N,M,B,D}) where {TA,TG,N,M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin 
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         it = point_time((b, r), lp)
 
         SFBC = ((B == BC_SF_AFWB) || (B == BC_SF_ORBI) ) 
@@ -131,6 +133,7 @@ function krnl_add_zth!(frc, frc2::AbstractArray{TA}, U::AbstractArray{TG}, lp::S
                     projalg(Ush[b]*X/Ush[b]))
             end
         end
+    end
     
     return nothing
 end
@@ -261,7 +264,9 @@ Eoft_plaq(U, gp::GaugeParm{T,G,NN}, lp::SpaceParm{N,M,B,D}, ymws::YMworkspace) w
 
 function krnl_plaq_pln!(plx, U::AbstractArray{T}, Ubnd, ztw, ipl, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
     
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
 
         id1, id2 = lp.plidx[ipl]
         SFBC = ((B == BC_SF_AFWB) || (B == BC_SF_ORBI)) && (id1 == lp.iL[end]) 
@@ -277,6 +282,7 @@ function krnl_plaq_pln!(plx, U::AbstractArray{T}, Ubnd, ztw, ipl, lp::SpaceParm{
         
         I = point_coord((b,r), lp)
         plx[I] = ztw*tr(U[b,id1,r]*gt / (U[b,id2,r]*U[bu2,id1,ru2]))
+    end
         
     return nothing
 end
@@ -387,29 +393,38 @@ Eoft_clover(U, gp::GaugeParm, lp::SpaceParm{N,M,B,D}, ymws::YMworkspace{T}) wher
 
 function krnl_add_et!(rm, op, frc1, U, lp::SpaceParm{4,M,B,D}) where {M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
 
         X1 = (frc1[b,1,r]+frc1[b,2,r]+frc1[b,3,r]+frc1[b,4,r])
         
         I = point_coord((b,r), lp)
         rm[I] = dot(X1,X1)
+    end
         
     return nothing
 end
 
 function krnl_add_qd!(rm, op, frc1, frc2, U, lp::SpaceParm{4,M,B,D}) where {M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
 
         I = point_coord((b,r), lp)
         rm[I] += op(dot( (frc1[b,1,r]+frc1[b,2,r]+frc1[b,3,r]+frc1[b,4,r]),
                          (frc2[b,1,r]+frc2[b,2,r]+frc2[b,3,r]+frc2[b,4,r]) ) )
+    end
+
     return nothing
 end
 
 function krnl_field_tensor!(frc1::AbstractArray{TA}, frc2, U::AbstractArray{T}, Ubnd, ipl1, ipl2, ztw1, ztw2, lp::SpaceParm{4,M,B,D}) where {TA,T,M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x)
+        r = Int64(CUDA.blockIdx().x)
         it = point_time((b,r), lp)
         SFBC = ((B == BC_SF_AFWB) || (B == BC_SF_ORBI) ) 
 
@@ -496,6 +511,7 @@ function krnl_field_tensor!(frc1::AbstractArray{TA}, frc2, U::AbstractArray{T},
             frc2[bd,3,rd]   = projalg(ztw2, gt2\(l2*gt1))
             frc2[bu2,4,ru2] = projalg(ztw2, l2*l1)
         end
+    end
         
     return nothing
 end

src/YM/YMsf.jl

@@ -44,7 +44,8 @@ end
     
 function krnl_sfcoupling!(rm, U::AbstractArray{T}, Ubnd, lp::SpaceParm{N,M,B,D}) where {T,N,M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x);  r = Int64(CUDA.blockIdx().x)
         I    = point_coord((b,r), lp)
         it   = I[N]
 
@@ -72,6 +73,7 @@ function krnl_sfcoupling!(rm, U::AbstractArray{T}, Ubnd, lp::SpaceParm{N,M,B,D})
                 rm[ID] += (2*X.t7 - SR3x2 * X.t8)/lp.iL[id]
             end
         end
+    end
         
     return nothing
 end
@@ -99,7 +101,8 @@ end
 
 function krnl_setbnd_it0!(U, phi1, phi2, lp::SpaceParm{N,M,B,D})  where {N,M,B,D}
 
-    b, r = assign_thx()
+    @inbounds begin
+        b = Int64(CUDA.threadIdx().x);  r = Int64(CUDA.blockIdx().x)
         it   = point_time((b,r), lp)
 
         SFBC = (B == BC_SF_AFWB) || (B == BC_SF_ORBI)
@@ -109,6 +112,7 @@ function krnl_setbnd_it0!(U, phi1, phi2, lp::SpaceParm{N,M,B,D})  where {N,M,B,D
                 U[b,id,r] = bndfield(phi1,phi2,lp.iL[id])
             end
         end
+    end
         
     return nothing
 end