Improve tile size decision making for fixed size dimensions.

Author: chriselrod

.gitignore

@@ -12,3 +12,4 @@ benchmark/#*#
 *.mod
 *.mod0
 *.so
+*.s

benchmark/looptests.c

@@ -140,12 +140,11 @@ void gemv(double* restrict y, double* restrict  A, double* restrict x, long M, l
 }
 void Atmulvb(double* restrict y, double* restrict  A, double* restrict x, long M, long K){
   for (long m = 0; m < M; m++){
-    y[m] = 0.0;
-  }
-  for (long m = 0; m < M; m++){
+    double ym = 0.0;
     for (long k = 0; k < K; k++){
-      y[m] += A[k + m*K] * x[k]; 
+      ym += A[k + m*K] * x[k]; 
     }
+    y[m] = ym;
   }
   return;
 }

benchmark/looptests.f90

@@ -221,18 +221,21 @@ subroutine Atmulvb(y, A, x, M, K) BIND(C, name="Atmulvb")
       real(C_double), intent(in) :: A(K,M), x(K)
       real(C_double), dimension(M), intent(out) :: y
       integer(C_long) :: mm, kk
-      y = 0.0
+      real(C_double) :: ymm
       do concurrent(mm = 1:M)
+         ymm = 0
          do concurrent(kk = 1:K)
-            y(mm) = y(mm) + A(kk,mm) * x(kk)
+            ymm = ymm + A(kk,mm) * x(kk)
          end do
+         y(mm) = ymm
       end do
     end subroutine Atmulvb
     subroutine Atmulvbbuiltin(y, A, x, M, K) BIND(C, name="Atmulvbbuiltin")
       integer(C_long), intent(in) :: M, K
-      real(C_double), intent(in) :: A(K,M), x(K)
-      real(C_double), dimension(M), intent(out) :: y
-      y = matmul(transpose(A), x)
+      real(C_double), intent(in) :: A(K,M), x(1,K)
+      real(C_double), dimension(1,M), intent(out) :: y
+      ! y = matmul(transpose(A), x)
+      y = matmul(x, A)
     end subroutine Atmulvbbuiltin
     subroutine unscaledvar(s, A, x, M, N) BIND(C, name="unscaledvar")
       integer(C_long), intent(in) :: M, N

benchmark/looptests.jl

@@ -119,11 +119,12 @@ function jgemv!(y, A, x)
 end
 @inline function jgemv!(y, Aᵀ::Adjoint, x)
     A = parent(Aᵀ)
-    y .= 0.0
     @inbounds for i ∈ eachindex(y)
+        yᵢ = 0.0
         @simd ivdep for j ∈ eachindex(x)
-            y[i] += A[j,i] * x[j]
+            yᵢ += A[j,i] * x[j]
         end
+        y[i] = yᵢ
     end
 end
 @inline function jgemvavx!(y, A, x)

src/determinestrategy.jl

@@ -270,43 +270,58 @@ function solve_tilesize(X, R, Umax, Tmax, UL, TL)
             T = Tmax
         else # U too large, resolve T
             U = Umax
-            T = solve_tilesize_constU(X, R, U)
+            T = min(Tmax, solve_tilesize_constU(X, R, U))
         end
     elseif T_too_large
         T = Tmax
-        U = solve_tilesize_constT(X, R, T)
+        U = min(Umax, solve_tilesize_constT(X, R, T))
     end
     U, T, cost
 end
 function maybedemotesize(U::Int, N::Int)
-    U > 1 || return 1
+    # U > 1 || return 1
     Um1 = U - 1
     urep = num_iterations(N, U)
     um1rep = num_iterations(N, Um1)
     um1rep > urep ? U : Um1
 end
+function maybedemotesize(T::Int, N::Int, U::Int, Uloop::Loop, maxTbase::Int)
+    T > 1 || return T
+    T == N && return T
+    T = maybedemotesize(T, N)
+    if !(isstaticloop(Uloop) && length(Uloop) == U)
+        if N % T != 0
+            T = min(T, maxTbase)
+        end
+    end
+    T
+end
 function solve_tilesize(
     ls::LoopSet, unrolled::Symbol, tiled::Symbol,
-    cost_vec::AbstractVector{Float64} = @view(ls.cost_vec[:,1]),
-    reg_pressure::AbstractVector{Int} = @view(ls.reg_pres[:,1])
+    cost_vec::AbstractVector{Float64}, 
+    reg_pressure::AbstractVector{Int},
+    W::Int, vectorized::Symbol
 )
-    maxT = 4#8
-    maxU = 4#8
+    maxTbase = maxUbase = 4
+    maxT = maxTbase#8
+    maxU = maxUbase#8
     tiledloop = getloop(ls, tiled)
     unrolledloop = getloop(ls, unrolled)
     if isstaticloop(tiledloop)
         maxT = min(4maxT, length(tiledloop))
     end
     if isstaticloop(unrolledloop)
-        maxU = min(4maxU, length(unrolledloop))
+        UL = length(unrolledloop)
+        UL = unrolled === vectorized ? cld(UL,W) : UL
+        maxU = min(4maxU, UL)
     end
     U, T, cost = solve_tilesize(cost_vec, reg_pressure, maxU, maxT, length(unrolledloop), length(tiledloop))
     # heuristic to more evenly divide small numbers of iterations
-    if isstaticloop(tiledloop) & T > 1
-        T = maybedemotesize(T, length(tiledloop))
+    if isstaticloop(tiledloop)
+        T = maybedemotesize(T, length(tiledloop), U, unrolledloop, maxTbase)
     end
     if isstaticloop(unrolledloop)
-        U = maybedemotesize(U, length(unrolledloop))
+        U = maybedemotesize(U, length(unrolledloop), T, tiledloop, maxUbase)
     end
     U, T, cost
 end
@@ -427,7 +442,7 @@ function evaluate_cost_tile(
     end
     # @show order, vectorized cost_vec reg_pressure
     # @show solve_tilesize(ls, unrolled, tiled, cost_vec, reg_pressure)
-    U, T, tcost = solve_tilesize(ls, unrolled, tiled, cost_vec, reg_pressure)
+    U, T, tcost = solve_tilesize(ls, unrolled, tiled, cost_vec, reg_pressure, W, vectorized)
     U, T, tcost + stride_penalty(ls, order)
 end