From 3f5585ea911f9dbae354a275eb7fbce8a4ea4c09 Mon Sep 17 00:00:00 2001
From: Andreas Kloeckner <inform@tiker.net>
Date: Wed, 25 Oct 2017 16:58:58 +0200
Subject: [PATCH] Placate flake8 re: usage of ell

---
 test/test_fortran.py    |  22 ++--
 test/test_linalg.py     |   8 +-
 test/test_reduction.py  |  10 +-
 test/test_statistics.py | 231 ++++++++++++++++++++--------------------
 4 files changed, 138 insertions(+), 133 deletions(-)

diff --git a/test/test_fortran.py b/test/test_fortran.py
index 6e05aa6ad..aa5a7e6e2 100644
--- a/test/test_fortran.py
+++ b/test/test_fortran.py
@@ -278,14 +278,14 @@ def test_matmul(ctx_factory, buffer_inames):
     logging.basicConfig(level=logging.INFO)
 
     fortran_src = """
-        subroutine dgemm(m,n,l,a,b,c)
+        subroutine dgemm(m,n,ell,a,b,c)
           implicit none
-          real*8 a(m,l),b(l,n),c(m,n)
-          integer m,n,k,i,j,l
+          real*8 a(m,ell),b(l,n),c(m,n)
+          integer m,n,k,i,j,ell
 
           do j = 1,n
             do i = 1,m
-              do k = 1,l
+              do k = 1,ell
                 c(i,j) = c(i,j) + b(k,j)*a(i,k)
               end do
             end do
@@ -317,7 +317,7 @@ def test_matmul(ctx_factory, buffer_inames):
             init_expression="0", store_expression="base+buffer")
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=128, m=128, l=128))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=128, m=128, ell=128))
 
 
 @pytest.mark.xfail
@@ -457,14 +457,14 @@ def test_parse_and_fuse_two_kernels():
 
 def test_precompute_some_exist(ctx_factory):
     fortran_src = """
-        subroutine dgemm(m,n,l,a,b,c)
+        subroutine dgemm(m,n,ell,a,b,c)
           implicit none
-          real*8 a(m,l),b(l,n),c(m,n)
-          integer m,n,k,i,j,l
+          real*8 a(m,ell),b(,n),c(m,n)
+          integer m,n,k,i,j,ell
 
           do j = 1,n
             do i = 1,m
-              do k = 1,l
+              do k = 1,ell
                 c(i,j) = c(i,j) + b(k,j)*a(i,k)
               end do
             end do
@@ -483,7 +483,7 @@ def test_precompute_some_exist(ctx_factory):
     knl = lp.split_iname(knl, "k", 8)
     knl = lp.assume(knl, "n mod 8 = 0")
     knl = lp.assume(knl, "m mod 8 = 0")
-    knl = lp.assume(knl, "l mod 8 = 0")
+    knl = lp.assume(knl, "ell mod 8 = 0")
 
     knl = lp.extract_subst(knl, "a_acc", "a[i1,i2]", parameters="i1, i2")
     knl = lp.extract_subst(knl, "b_acc", "b[i1,i2]", parameters="i1, i2")
@@ -495,7 +495,7 @@ def test_precompute_some_exist(ctx_factory):
     ref_knl = knl
 
     ctx = ctx_factory()
-    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=128, m=128, l=128))
+    lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters=dict(n=128, m=128, ell=128))
 
 
 if __name__ == "__main__":
diff --git a/test/test_linalg.py b/test/test_linalg.py
index 772d536d1..3d422f1d8 100644
--- a/test/test_linalg.py
+++ b/test/test_linalg.py
@@ -230,14 +230,14 @@ def test_funny_shape_matrix_mul(ctx_factory):
 
     n = get_suitable_size(ctx)
     m = n+12
-    l = m+12
+    ell = m+12
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 "c[i, j] = sum(k, a[i, k]*b[k, j])"
                 ],
-            name="matmul", assumptions="n,m,l >= 1")
+            name="matmul", assumptions="n,m,ell >= 1")
 
     knl = lp.add_dtypes(knl, {
         "a": np.float32,
@@ -261,7 +261,7 @@ def test_funny_shape_matrix_mul(ctx_factory):
 
     lp.auto_test_vs_ref(ref_knl, ctx, knl,
             op_count=[2*n**3/1e9], op_label=["GFlops"],
-            parameters={"n": n, "m": m, "l": l})
+            parameters={"n": n, "m": m, "ell": ell})
 
 
 def test_rank_one(ctx_factory):
diff --git a/test/test_reduction.py b/test/test_reduction.py
index 555b8c0cc..0c37d2228 100644
--- a/test/test_reduction.py
+++ b/test/test_reduction.py
@@ -97,22 +97,22 @@ def test_nested_dependent_reduction(ctx_factory):
                 "{[j]: 0<=j<i+sumlen}"
                 ],
             [
-                "<> sumlen = l[i]",
+                "<> sumlen = ell[i]",
                 "a[i] = sum(j, j)",
                 ],
             [
                 lp.ValueArg("n", np.int32),
                 lp.GlobalArg("a", dtype, ("n",)),
-                lp.GlobalArg("l", np.int32, ("n",)),
+                lp.GlobalArg("ell", np.int32, ("n",)),
                 ])
 
     cknl = lp.CompiledKernel(ctx, knl)
 
     n = 330
-    l = np.arange(n, dtype=np.int32)
-    evt, (a,) = cknl(queue, l=l, n=n, out_host=True)
+    ell = np.arange(n, dtype=np.int32)
+    evt, (a,) = cknl(queue, ell=ell, n=n, out_host=True)
 
-    tgt_result = (2*l-1)*2*l/2
+    tgt_result = (2*ell-1)*2*ell/2
     assert (a == tgt_result).all()
 
 
diff --git a/test/test_statistics.py b/test/test_statistics.py
index cf86539ef..3b33a8eff 100644
--- a/test/test_statistics.py
+++ b/test/test_statistics.py
@@ -37,14 +37,14 @@ from pymbolic.primitives import Variable
 def test_op_counter_basic():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
                 e[i, k+1] = -g[i,k]*h[i,k+1]
                 """
             ],
-            name="basic", assumptions="n,m,l >= 1")
+            name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
                                   dict(a=np.float32, b=np.float32,
@@ -52,14 +52,14 @@ def test_op_counter_basic():
     op_map = lp.get_op_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32add = op_map[lp.Op(np.float32, 'add')].eval_with_dict(params)
     f32mul = op_map[lp.Op(np.float32, 'mul')].eval_with_dict(params)
     f32div = op_map[lp.Op(np.float32, 'div')].eval_with_dict(params)
     f64mul = op_map[lp.Op(np.dtype(np.float64), 'mul')].eval_with_dict(params)
     i32add = op_map[lp.Op(np.dtype(np.int32), 'add')].eval_with_dict(params)
-    assert f32add == f32mul == f32div == n*m*l
+    assert f32add == f32mul == f32div == n*m*ell
     assert f64mul == n*m
     assert i32add == n*m*2
 
@@ -67,21 +67,21 @@ def test_op_counter_basic():
 def test_op_counter_reduction():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 "c[i, j] = sum(k, a[i, k]*b[k, j])"
             ],
-            name="matmul_serial", assumptions="n,m,l >= 1")
+            name="matmul_serial", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
     op_map = lp.get_op_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32add = op_map[lp.Op(np.float32, 'add')].eval_with_dict(params)
     f32mul = op_map[lp.Op(np.dtype(np.float32), 'mul')].eval_with_dict(params)
-    assert f32add == f32mul == n*m*l
+    assert f32add == f32mul == n*m*ell
 
     op_map_dtype = op_map.group_by('dtype')
     f32 = op_map_dtype[lp.Op(dtype=np.float32)].eval_with_dict(params)
@@ -91,20 +91,23 @@ def test_op_counter_reduction():
 def test_op_counter_logic():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
-                e[i,k] = if(not(k<l-2) and k>6 or k/2==l, g[i,k]*2, g[i,k]+h[i,k]/2)
+                e[i,k] = if(
+                        not(k<ell-2) and k>6 or k/2==ell,
+                        g[i,k]*2,
+                        g[i,k]+h[i,k]/2)
                 """
             ],
-            name="logic", assumptions="n,m,l >= 1")
+            name="logic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(g=np.float32, h=np.float64))
     op_map = lp.get_op_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32mul = op_map[lp.Op(np.float32, 'mul')].eval_with_dict(params)
     f64add = op_map[lp.Op(np.float64, 'add')].eval_with_dict(params)
     f64div = op_map[lp.Op(np.dtype(np.float64), 'div')].eval_with_dict(params)
@@ -118,14 +121,14 @@ def test_op_counter_logic():
 def test_op_counter_specialops():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = (2*a[i,j,k])%(2+b[i,j,k]/3.0)
                 e[i, k] = (1+g[i,k])**(1+h[i,k+1])+rsqrt(g[i,k])*sin(g[i,k])
                 """
             ],
-            name="specialops", assumptions="n,m,l >= 1")
+            name="specialops", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
                                   dict(a=np.float32, b=np.float32,
@@ -133,8 +136,8 @@ def test_op_counter_specialops():
     op_map = lp.get_op_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32mul = op_map[lp.Op(np.float32, 'mul')].eval_with_dict(params)
     f32div = op_map[lp.Op(np.float32, 'div')].eval_with_dict(params)
     f32add = op_map[lp.Op(np.float32, 'add')].eval_with_dict(params)
@@ -143,8 +146,8 @@ def test_op_counter_specialops():
     i32add = op_map[lp.Op(np.dtype(np.int32), 'add')].eval_with_dict(params)
     f64rsq = op_map[lp.Op(np.dtype(np.float64), 'func:rsqrt')].eval_with_dict(params)
     f64sin = op_map[lp.Op(np.dtype(np.float64), 'func:sin')].eval_with_dict(params)
-    assert f32div == 2*n*m*l
-    assert f32mul == f32add == n*m*l
+    assert f32div == 2*n*m*ell
+    assert f32mul == f32add == n*m*ell
     assert f64add == 3*n*m
     assert f64pow == i32add == f64rsq == f64sin == n*m
 
@@ -152,14 +155,14 @@ def test_op_counter_specialops():
 def test_op_counter_bitwise():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = (a[i,j,k] | 1) + (b[i,j,k] & 1)
                 e[i, k] = (g[i,k] ^ k)*(~h[i,k+1]) + (g[i, k] << (h[i,k] >> k))
                 """
             ],
-            name="bitwise", assumptions="n,m,l >= 1")
+            name="bitwise", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(
             knl, dict(
@@ -169,16 +172,16 @@ def test_op_counter_bitwise():
     op_map = lp.get_op_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     i32add = op_map[lp.Op(np.int32, 'add')].eval_with_dict(params)
     i32bw = op_map[lp.Op(np.int32, 'bw')].eval_with_dict(params)
     i64bw = op_map[lp.Op(np.dtype(np.int64), 'bw')].eval_with_dict(params)
     i64mul = op_map[lp.Op(np.dtype(np.int64), 'mul')].eval_with_dict(params)
     i64add = op_map[lp.Op(np.dtype(np.int64), 'add')].eval_with_dict(params)
     i64shift = op_map[lp.Op(np.dtype(np.int64), 'shift')].eval_with_dict(params)
-    assert i32add == n*m+n*m*l
-    assert i32bw == 2*n*m*l
+    assert i32add == n*m+n*m*ell
+    assert i32bw == 2*n*m*ell
     assert i64bw == 2*n*m
     assert i64add == i64mul == n*m
     assert i64shift == 2*n*m
@@ -218,22 +221,22 @@ def test_op_counter_triangular_domain():
 def test_mem_access_counter_basic():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
                 e[i, k] = g[i,k]*h[i,k+1]
                 """
             ],
-            name="basic", assumptions="n,m,l >= 1")
+            name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
                         dict(a=np.float32, b=np.float32, g=np.float64, h=np.float64))
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32l = mem_map[lp.MemAccess('global', np.float32,
                          stride=0, direction='load', variable='a')
                    ].eval_with_dict(params)
@@ -246,7 +249,7 @@ def test_mem_access_counter_basic():
     f64l += mem_map[lp.MemAccess('global', np.float64,
                           stride=0, direction='load', variable='h')
                     ].eval_with_dict(params)
-    assert f32l == 3*n*m*l
+    assert f32l == 3*n*m*ell
     assert f64l == 2*n*m
 
     f32s = mem_map[lp.MemAccess('global', np.dtype(np.float32),
@@ -255,37 +258,37 @@ def test_mem_access_counter_basic():
     f64s = mem_map[lp.MemAccess('global', np.dtype(np.float64),
                          stride=0, direction='store', variable='e')
                    ].eval_with_dict(params)
-    assert f32s == n*m*l
+    assert f32s == n*m*ell
     assert f64s == n*m
 
 
 def test_mem_access_counter_reduction():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 "c[i, j] = sum(k, a[i, k]*b[k, j])"
             ],
-            name="matmul", assumptions="n,m,l >= 1")
+            name="matmul", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32l = mem_map[lp.MemAccess('global', np.float32,
                          stride=0, direction='load', variable='a')
                    ].eval_with_dict(params)
     f32l += mem_map[lp.MemAccess('global', np.float32,
                           stride=0, direction='load', variable='b')
                     ].eval_with_dict(params)
-    assert f32l == 2*n*m*l
+    assert f32l == 2*n*m*ell
 
     f32s = mem_map[lp.MemAccess('global', np.dtype(np.float32),
                          stride=0, direction='store', variable='c')
                    ].eval_with_dict(params)
-    assert f32s == n*l
+    assert f32s == n*ell
 
     ld_bytes = mem_map.filter_by(mtype=['global'], direction=['load']
                                  ).to_bytes().eval_and_sum(params)
@@ -298,20 +301,22 @@ def test_mem_access_counter_reduction():
 def test_mem_access_counter_logic():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
-                e[i,k] = if(not(k<l-2) and k>6 or k/2==l, g[i,k]*2, g[i,k]+h[i,k]/2)
+                e[i,k] = if(not(k<ell-2) and k>6 or k/2==ell,
+                    g[i,k]*2,
+                    g[i,k]+h[i,k]/2)
                 """
             ],
-            name="logic", assumptions="n,m,l >= 1")
+            name="logic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(g=np.float32, h=np.float64))
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
 
     reduced_map = mem_map.group_by('mtype', 'dtype', 'direction')
 
@@ -332,22 +337,22 @@ def test_mem_access_counter_logic():
 def test_mem_access_counter_specialops():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = (2*a[i,j,k])%(2+b[i,j,k]/3.0)
                 e[i, k] = (1+g[i,k])**(1+h[i,k+1])
                 """
             ],
-            name="specialops", assumptions="n,m,l >= 1")
+            name="specialops", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32,
                                             g=np.float64, h=np.float64))
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f32 = mem_map[lp.MemAccess('global', np.float32,
                          stride=0, direction='load', variable='a')
                   ].eval_with_dict(params)
@@ -360,7 +365,7 @@ def test_mem_access_counter_specialops():
     f64 += mem_map[lp.MemAccess('global', np.dtype(np.float64),
                           stride=0, direction='load', variable='h')
                    ].eval_with_dict(params)
-    assert f32 == 2*n*m*l
+    assert f32 == 2*n*m*ell
     assert f64 == 2*n*m
 
     f32 = mem_map[lp.MemAccess('global', np.float32,
@@ -369,26 +374,26 @@ def test_mem_access_counter_specialops():
     f64 = mem_map[lp.MemAccess('global', np.float64,
                          stride=0, direction='store', variable='e')
                   ].eval_with_dict(params)
-    assert f32 == n*m*l
+    assert f32 == n*m*ell
     assert f64 == n*m
 
     filtered_map = mem_map.filter_by(direction=['load'], variable=['a', 'g'])
     #tot = lp.eval_and_sum_polys(filtered_map, params)
     tot = filtered_map.eval_and_sum(params)
-    assert tot == n*m*l + n*m
+    assert tot == n*m*ell + n*m
 
 
 def test_mem_access_counter_bitwise():
 
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = (a[i,j,k] | 1) + (b[i,j,k] & 1)
                 e[i, k] = (g[i,k] ^ k)*(~h[i,k+1]) + (g[i, k] << (h[i,k] >> k))
                 """
             ],
-            name="bitwise", assumptions="n,m,l >= 1")
+            name="bitwise", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(
             knl, dict(
@@ -398,8 +403,8 @@ def test_mem_access_counter_bitwise():
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     i32 = mem_map[lp.MemAccess('global', np.int32,
                          stride=0, direction='load', variable='a')
                   ].eval_with_dict(params)
@@ -412,7 +417,7 @@ def test_mem_access_counter_bitwise():
     i32 += mem_map[lp.MemAccess('global', np.dtype(np.int32),
                           stride=0, direction='load', variable='h')
                    ].eval_with_dict(params)
-    assert i32 == 4*n*m+2*n*m*l
+    assert i32 == 4*n*m+2*n*m*ell
 
     i32 = mem_map[lp.MemAccess('global', np.int32,
                          stride=0, direction='store', variable='c')
@@ -420,20 +425,20 @@ def test_mem_access_counter_bitwise():
     i32 += mem_map[lp.MemAccess('global', np.int32,
                           stride=0, direction='store', variable='e')
                    ].eval_with_dict(params)
-    assert i32 == n*m+n*m*l
+    assert i32 == n*m+n*m*ell
 
 
 def test_mem_access_counter_mixed():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
             c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]+x[i,k]
             e[i, k] = g[i,k]*(2+h[i,k])
             """
             ],
-            name="mixed", assumptions="n,m,l >= 1")
+            name="mixed", assumptions="n,m,ell >= 1")
     knl = lp.add_and_infer_dtypes(knl, dict(
                 a=np.float32, b=np.float32, g=np.float64, h=np.float64,
                 x=np.float32))
@@ -444,8 +449,8 @@ def test_mem_access_counter_mixed():
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)  # noqa
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f64uniform = mem_map[lp.MemAccess('global', np.float64,
                                 stride=0, direction='load', variable='g')
                          ].eval_with_dict(params)
@@ -463,9 +468,9 @@ def test_mem_access_counter_mixed():
                                    stride=Variable('m'), direction='load',
                                    variable='b')
                             ].eval_with_dict(params)
-    assert f64uniform == 2*n*m*l/bsize
-    assert f32uniform == n*m*l/bsize
-    assert f32nonconsec == 3*n*m*l
+    assert f64uniform == 2*n*m*ell/bsize
+    assert f32uniform == n*m*ell/bsize
+    assert f32nonconsec == 3*n*m*ell
 
     f64uniform = mem_map[lp.MemAccess('global', np.float64,
                                 stride=0, direction='store', variable='e')
@@ -474,21 +479,21 @@ def test_mem_access_counter_mixed():
                                   stride=Variable('m'), direction='store',
                                   variable='c')
                            ].eval_with_dict(params)
-    assert f64uniform == n*m*l/bsize
-    assert f32nonconsec == n*m*l
+    assert f64uniform == n*m*ell/bsize
+    assert f32nonconsec == n*m*ell
 
 
 def test_mem_access_counter_nonconsec():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
             c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
             e[i, k] = g[i,k]*(2+h[i,k])
             """
             ],
-            name="nonconsec", assumptions="n,m,l >= 1")
+            name="nonconsec", assumptions="n,m,ell >= 1")
     knl = lp.add_and_infer_dtypes(knl, dict(
                 a=np.float32, b=np.float32, g=np.float64, h=np.float64))
     knl = lp.split_iname(knl, "i", 16)
@@ -497,8 +502,8 @@ def test_mem_access_counter_nonconsec():
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)  # noqa
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     f64nonconsec = mem_map[lp.MemAccess('global', np.float64,
                                   stride=Variable('m'), direction='load',
                                   variable='g')
@@ -508,39 +513,39 @@ def test_mem_access_counter_nonconsec():
                                    variable='h')
                             ].eval_with_dict(params)
     f32nonconsec = mem_map[lp.MemAccess('global', np.dtype(np.float32),
-                                  stride=Variable('m')*Variable('l'),
+                                  stride=Variable('m')*Variable('ell'),
                                   direction='load', variable='a')
                            ].eval_with_dict(params)
     f32nonconsec += mem_map[lp.MemAccess('global', np.dtype(np.float32),
-                                   stride=Variable('m')*Variable('l'),
+                                   stride=Variable('m')*Variable('ell'),
                                    direction='load', variable='b')
                             ].eval_with_dict(params)
     assert f64nonconsec == 2*n*m
-    assert f32nonconsec == 3*n*m*l
+    assert f32nonconsec == 3*n*m*ell
 
     f64nonconsec = mem_map[lp.MemAccess('global', np.float64,
                                   stride=Variable('m'), direction='store',
                                   variable='e')
                            ].eval_with_dict(params)
     f32nonconsec = mem_map[lp.MemAccess('global', np.float32,
-                                  stride=Variable('m')*Variable('l'),
+                                  stride=Variable('m')*Variable('ell'),
                                   direction='store', variable='c')
                            ].eval_with_dict(params)
     assert f64nonconsec == n*m
-    assert f32nonconsec == n*m*l
+    assert f32nonconsec == n*m*ell
 
 
 def test_mem_access_counter_consec():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
             c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
             e[i, k] = g[i,k]*(2+h[i,k])
             """
             ],
-            name="consec", assumptions="n,m,l >= 1")
+            name="consec", assumptions="n,m,ell >= 1")
     knl = lp.add_and_infer_dtypes(knl, dict(
                 a=np.float32, b=np.float32, g=np.float64, h=np.float64))
     knl = lp.tag_inames(knl, {"k": "l.0", "i": "g.0", "j": "g.1"})
@@ -548,8 +553,8 @@ def test_mem_access_counter_consec():
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
 
     f64consec = mem_map[lp.MemAccess('global', np.float64,
                         stride=1, direction='load', variable='g')
@@ -563,8 +568,8 @@ def test_mem_access_counter_consec():
     f32consec += mem_map[lp.MemAccess('global', np.dtype(np.float32),
                         stride=1, direction='load', variable='b')
                          ].eval_with_dict(params)
-    assert f64consec == 2*n*m*l
-    assert f32consec == 3*n*m*l
+    assert f64consec == 2*n*m*ell
+    assert f32consec == 3*n*m*ell
 
     f64consec = mem_map[lp.MemAccess('global', np.float64,
                         stride=1, direction='store', variable='e')
@@ -572,29 +577,29 @@ def test_mem_access_counter_consec():
     f32consec = mem_map[lp.MemAccess('global', np.float32,
                         stride=1, direction='store', variable='c')
                         ].eval_with_dict(params)
-    assert f64consec == n*m*l
-    assert f32consec == n*m*l
+    assert f64consec == n*m*ell
+    assert f32consec == n*m*ell
 
 
 def test_barrier_counter_nobarriers():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
                 e[i, k] = g[i,k]*h[i,k+1]
                 """
             ],
-            name="basic", assumptions="n,m,l >= 1")
+            name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32,
                                             g=np.float64, h=np.float64))
     sync_map = lp.get_synchronization_map(knl)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     assert len(sync_map) == 1
     assert sync_map["kernel_launch"].eval_with_dict(params) == 1
 
@@ -602,7 +607,7 @@ def test_barrier_counter_nobarriers():
 def test_barrier_counter_barriers():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<50 and 1<=k<98 and 0<=j<10}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<50 and 1<=k<98 and 0<=j<10}",
             [
                 """
             c[i,j,k] = 2*a[i,j,k] {id=first}
@@ -620,8 +625,8 @@ def test_barrier_counter_barriers():
     print(sync_map)
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
     barrier_count = sync_map["barrier_local"].eval_with_dict(params)
     assert barrier_count == 50*10*2
 
@@ -630,13 +635,13 @@ def test_all_counters_parallel_matmul():
 
     bsize = 16
     knl = lp.make_kernel(
-            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 "c[i, j] = sum(k, a[i, k]*b[k, j])"
             ],
-            name="matmul", assumptions="n,m,l >= 1")
+            name="matmul", assumptions="n,m,ell >= 1")
     knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
-    knl = lp.split_iname(knl, "i", bsize, outer_tag="g.0", inner_tag="l.1")
+    knl = lp.split_iname(knl, "i", bsize, outer_tag="g.0", inner_tag="ell.1")
     knl = lp.split_iname(knl, "j", bsize, outer_tag="g.1", inner_tag="l.0")
     knl = lp.split_iname(knl, "k", bsize)
     knl = lp.add_prefetch(knl, "a", ["k_inner", "i_inner"])
@@ -644,8 +649,8 @@ def test_all_counters_parallel_matmul():
 
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
 
     sync_map = lp.get_synchronization_map(knl)
     assert len(sync_map) == 2
@@ -666,7 +671,7 @@ def test_all_counters_parallel_matmul():
                         lp.Op(np.dtype(np.int32), 'mul')
                         ].eval_with_dict(params)
 
-    assert f32mul+f32add == n*m*l*2
+    assert f32mul+f32add == n*m*ell*2
 
     op_map = lp.get_mem_access_map(knl, count_redundant_work=True)
 
@@ -677,21 +682,21 @@ def test_all_counters_parallel_matmul():
                      stride=1, direction='load', variable='a')
                      ].eval_with_dict(params)
 
-    assert f32s1lb == n*m*l/bsize
-    assert f32s1la == n*m*l/bsize
+    assert f32s1lb == n*m*ell/bsize
+    assert f32s1la == n*m*ell/bsize
 
     f32coal = op_map[lp.MemAccess('global', np.float32,
                      stride=1, direction='store', variable='c')
                      ].eval_with_dict(params)
 
-    assert f32coal == n*l
+    assert f32coal == n*ell
 
     local_mem_map = lp.get_mem_access_map(knl,
                         count_redundant_work=True).filter_by(mtype=['local'])
     local_mem_l = local_mem_map[lp.MemAccess('local', np.dtype(np.float32),
                                              direction='load')
                                 ].eval_with_dict(params)
-    assert local_mem_l == n*m*l*2
+    assert local_mem_l == n*m*ell*2
 
 
 def test_gather_access_footprint():
@@ -729,38 +734,38 @@ def test_gather_access_footprint_2():
 def test_summations_and_filters():
 
     knl = lp.make_kernel(
-            "[n,m,l] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<l}",
+            "[n,m,ell] -> {[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
             [
                 """
                 c[i, j, k] = a[i,j,k]*b[i,j,k]/3.0+a[i,j,k]
                 e[i, k+1] = -g[i,k]*h[i,k+1]
                 """
             ],
-            name="basic", assumptions="n,m,l >= 1")
+            name="basic", assumptions="n,m,ell >= 1")
 
     knl = lp.add_and_infer_dtypes(knl,
                         dict(a=np.float32, b=np.float32, g=np.float64, h=np.float64))
     n = 512
     m = 256
-    l = 128
-    params = {'n': n, 'm': m, 'l': l}
+    ell = 128
+    params = {'n': n, 'm': m, 'ell': ell}
 
     mem_map = lp.get_mem_access_map(knl, count_redundant_work=True)
 
     loads_a = mem_map.filter_by(direction=['load'], variable=['a']
                                 ).eval_and_sum(params)
-    assert loads_a == 2*n*m*l
+    assert loads_a == 2*n*m*ell
 
     global_stores = mem_map.filter_by(mtype=['global'], direction=['store']
                                       ).eval_and_sum(params)
-    assert global_stores == n*m*l + n*m
+    assert global_stores == n*m*ell + n*m
 
     ld_bytes = mem_map.filter_by(mtype=['global'], direction=['load']
                                  ).to_bytes().eval_and_sum(params)
     st_bytes = mem_map.filter_by(mtype=['global'], direction=['store']
                                  ).to_bytes().eval_and_sum(params)
-    assert ld_bytes == 4*n*m*l*3 + 8*n*m*2
-    assert st_bytes == 4*n*m*l + 8*n*m
+    assert ld_bytes == 4*n*m*ell*3 + 8*n*m*2
+    assert st_bytes == 4*n*m*ell + 8*n*m
 
     # ignore stride and variable names in this map
     reduced_map = mem_map.group_by('mtype', 'dtype', 'direction')
@@ -768,7 +773,7 @@ def test_summations_and_filters():
                           ].eval_with_dict(params)
     f64lall = reduced_map[lp.MemAccess('global', np.float64, direction='load')
                           ].eval_with_dict(params)
-    assert f32lall == 3*n*m*l
+    assert f32lall == 3*n*m*ell
     assert f64lall == 2*n*m
 
     op_map = lp.get_op_map(knl, count_redundant_work=True)
@@ -779,14 +784,14 @@ def test_summations_and_filters():
     f32 = op_map_dtype[lp.Op(dtype=np.float32)].eval_with_dict(params)
     f64 = op_map_dtype[lp.Op(dtype=np.float64)].eval_with_dict(params)
     i32 = op_map_dtype[lp.Op(dtype=np.int32)].eval_with_dict(params)
-    assert f32 == n*m*l*3
+    assert f32 == n*m*ell*3
     assert f64 == n*m
     assert i32 == n*m*2
 
     addsub_all = op_map.filter_by(name=['add', 'sub']).eval_and_sum(params)
     f32ops_all = op_map.filter_by(dtype=[np.float32]).eval_and_sum(params)
-    assert addsub_all == n*m*l + n*m*2
-    assert f32ops_all == n*m*l*3
+    assert addsub_all == n*m*ell + n*m*2
+    assert f32ops_all == n*m*ell*3
 
     non_field = op_map.filter_by(xxx=[np.float32]).eval_and_sum(params)
     assert non_field == 0
@@ -795,7 +800,7 @@ def test_summations_and_filters():
     ops_noname = op_map.group_by('dtype')
     mul_all = ops_nodtype[lp.Op(name='mul')].eval_with_dict(params)
     f64ops_all = ops_noname[lp.Op(dtype=np.float64)].eval_with_dict(params)
-    assert mul_all == n*m*l + n*m
+    assert mul_all == n*m*ell + n*m
     assert f64ops_all == n*m
 
     def func_filter(key):
-- 
GitLab