feat(tests): use logger instead of printing

Author: alexfikl

test/test_apps.py

@@ -217,7 +217,7 @@ def test_rob_stroud_bernstein():
                 "coeffs": np.float32,
                 "tmp": np.float32,
                 })
-    print(lp.generate_code_v2(knl))
+    logger.info("%s", lp.generate_code_v2(knl))
 
 
 def test_rob_stroud_bernstein_full():
@@ -302,7 +302,7 @@ def test_rob_stroud_bernstein_full():
                 "coeffs": np.float32,
                 "result": np.float32,
                 })
-    print(lp.generate_code_v2(knl))
+    logger.info("%s", lp.generate_code_v2(knl))
 
 
 def test_stencil(ctx_factory):
@@ -424,7 +424,7 @@ def test_sum_factorization():
     knl = lp.extract_subst(knl, "temp_array",
             "sum(k, phi1(i,x[0,k]) *psi1(ip, x[0,k]) * w[0,k])")
 
-    print(knl)
+    logger.info("%s", knl)
 
 
 def test_lbm(ctx_factory):
@@ -517,7 +517,7 @@ def test_fd_demo():
     knl = lp.set_options(knl, write_code=True)
     knl = lp.add_and_infer_dtypes(knl, {"u": np.float32})
     code, _inf = lp.generate_code(knl)
-    print(code)
+    logger.info("%s", code)
 
     assert "double" not in code
 
@@ -564,8 +564,7 @@ def test_poisson_fem(ctx_factory):
                     J[c] * w[k] * sum(ell, dpsi(i,k,ell) * dpsi(j,k,ell))
             """,
             assumptions="nels>=1 and nbf >= 1 and nels mod 4 = 0")
-
-    print(knl)
+    logger.info("%s", knl)
 
     knl = lp.fix_parameters(knl, nbf=nbf, sdim=sdim, nqp=nqp)
 
@@ -702,7 +701,7 @@ def test_abs_as_index():
             lp.GlobalArg("a", np.float32),
             ...
             ])
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 
 def test_sumpy_p2p_reduced():

test/test_callables.py

@@ -1215,7 +1215,7 @@ def test_inlining_does_not_require_barrier(inline):
         t_unit = lp.inline_callable_kernel(t_unit, "fft")
 
     # generate code to ensure that we don't emit spurious missing barrier
-    print(lp.generate_code_v2(t_unit).device_code())
+    logger.info("%s", lp.generate_code_v2(t_unit).device_code())
 
 
 def test_inlining_w_zero_stride_callee_args(ctx_factory):

test/test_diff.py

@@ -61,7 +61,7 @@ def test_diff(ctx_factory):
 
     dknl = lp.add_inames_to_insn(dknl, "diff_i0", "writes:a_dx or writes:a")
 
-    print(dknl)
+    logger.info("%s", dknl)
 
     n = 50
     x = rng.normal(size=n)
@@ -88,7 +88,7 @@ def test_diff(ctx_factory):
 
     err1 = la.norm(diff1 - diff1_predicted) / la.norm(diff1)
     err2 = la.norm(diff2 - diff2_predicted) / la.norm(diff2)
-    print(err1, err2)
+    logger.info("error %.16e %.16e", err1, err2)
 
     assert (err2 < err1 * fac * 1.1).all()
 

test/test_domain.py

@@ -94,7 +94,7 @@ def test_eq_constraint():
 
     knl = lp.split_iname(knl, "i", 16, outer_tag="g.0")
     knl = lp.split_iname(knl, "i_inner", 16, outer_tag=None, inner_tag="l.0")
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 
 def test_dependent_loop_bounds():
@@ -119,7 +119,7 @@ def test_dependent_loop_bounds():
             assumptions="n>=1 and row_len>=1",
             target=lp.PyOpenCLTarget())
 
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 
 def test_dependent_loop_bounds_2():
@@ -148,7 +148,7 @@ def test_dependent_loop_bounds_2():
     knl = lp.split_iname(knl, "i", 128, outer_tag="g.0",
             inner_tag="l.0")
 
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 
 def test_dependent_loop_bounds_3():
@@ -181,7 +181,7 @@ def test_dependent_loop_bounds_3():
     knl = lp.split_iname(knl, "i", 128, outer_tag="g.0",
             inner_tag="l.0")
 
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
     knl_bad = lp.split_iname(knl, "jj", 128, outer_tag="g.1",
             inner_tag="l.1")
@@ -290,9 +290,6 @@ def test_equality_constraints(ctx_factory):
 
     knl = lp.add_inames_to_insn(knl, "j_inner, j_outer", "id:set_b")
 
-    # print(knl)
-    # print(knl.domains[0].detect_equalities())
-
     lp.auto_test_vs_ref(seq_knl, ctx, knl,
             parameters={"n": n}, print_ref_code=True)
 
@@ -358,8 +355,8 @@ def test_triangle_domain():
             assumptions="n>=1",
             target=lp.PyOpenCLTarget())
 
-    print(knl)
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", knl)
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 
 if __name__ == "__main__":

test/test_expression.py

@@ -223,11 +223,15 @@ def generate_random_fuzz_examples(expr_type):
 
 def assert_parse_roundtrip(expr):
     from pymbolic.mapper.stringifier import StringifyMapper
+
     strified = StringifyMapper()(expr)
+
     from pymbolic import parse
+
     parsed_expr = parse(strified)
-    print(expr)
-    print(parsed_expr)
+    logger.info("expr:   %s", expr)
+    logger.info("parsed: %s", parsed_expr)
+
     assert expr == parsed_expr
 
 
@@ -279,21 +283,17 @@ def get_numpy_type(x):
 
         var_name = "expr%d" % i
 
-        # print(expr)
-        # assert_parse_roundtrip(expr)
-
         if expr_type in ["int", "int_nonneg"]:
             result_type_iinfo = np.iinfo(np.int32)
             bceval_mapper = BoundsCheckingEvaluationMapper(
                     var_values,
                     lbound=result_type_iinfo.min,
                     ubound=result_type_iinfo.max)
-            # print(expr)
             try:
                 ref_values[var_name] = bceval_mapper(expr)
             except BoundsCheckError:
-                print(expr)
-                print("BOUNDS CHECK FAILED")
+                logger.info("expr: %s", expr)
+                logger.error("BOUNDS CHECK FAILED")
                 continue
         else:
             try:
@@ -350,7 +350,6 @@ def get_numpy_type(x):
                 " and ".join("%s >= 0" % name for name in var_names))))
 
     knl = lp.set_options(knl, return_dict=True)
-    # print(knl)
 
     if type(target) is lp.PyOpenCLTarget:
         cl_ctx = ctx_factory()
@@ -372,18 +371,17 @@ def get_numpy_type(x):
             raise AssertionError()
 
         if abs(err) > 1e-10:
-            print(80*"-")
-            print(knl)
-            print(80*"-")
-            print(lp.generate_code_v2(knl).device_code())
-            print(80*"-")
-            print(f"WRONG: {name} rel error={err:g}")
-            print("reference=%r" % ref_value)
-            print("loopy=%r" % lp_value)
-            print(80*"-")
-            1/0  # noqa: B018
-
-    print(lp.generate_code_v2(knl).device_code())
+            logger.info(80*"-")
+            logger.info("%s", knl)
+            logger.info(80*"-")
+            logger.info("%s", lp.generate_code_v2(knl).device_code())
+            logger.info(80*"-")
+            logger.info("WRONG: %s rel error=%g", name, err)
+            logger.info("reference=%r", ref_value)
+            logger.info("loopy=%r", lp_value)
+            logger.info(80*"-")
+
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
 # }}}
 
@@ -467,14 +465,16 @@ def test_integer_associativity():
             s := (i % elemsize)
             v[i] = u[ncomp * indices[(s) + elemsize*(e)] + (d)]
             """)
-
     knl = lp.add_and_infer_dtypes(
             knl, {"u": np.float64, "elemsize, ncomp, indices": np.int32})
+
     import islpy as isl
+
     knl = lp.assume(
             knl, isl.BasicSet("[elemsize, ncomp] -> "
             "{ : elemsize>= 0 and ncomp >= 0}"))
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
+
     assert (
             "u[ncomp * indices[i % elemsize + elemsize "
             "* (i / (ncomp * elemsize))] "
@@ -506,7 +506,7 @@ def test_divide_precedence(ctx_factory):
             """,
             [lp.ValueArg("a, b, c", np.int32),
                 lp.GlobalArg("x, y", np.int32, shape=lp.auto)])
-    print(lp.generate_code_v2(knl).device_code())
+    logger.info("%s", lp.generate_code_v2(knl).device_code())
 
     evt, (x_out, y_out) = knl(queue, c=2, b=2, a=5)
     evt.wait()

test/test_fortran.py

@@ -80,7 +80,7 @@ def test_assign_double_precision_scalar(ctx_factory):
         """
 
     t_unit = lp.parse_fortran(fortran_src)
-    print(lp.generate_code_v2(t_unit).device_code())
+    logger.info("%s", lp.generate_code_v2(t_unit).device_code())
     assert "1.1;" in lp.generate_code_v2(t_unit).device_code()
 
     a_dev = cl.array.empty(queue, 1, dtype=np.float64, order="F")
@@ -625,7 +625,7 @@ def test_fortran_subroutines():
         end subroutine
         """
     t_unit = lp.parse_fortran(fortran_src).with_entrypoints("twice_cross")
-    print(lp.generate_code_v2(t_unit).device_code())
+    logger.info("%s", lp.generate_code_v2(t_unit).device_code())
 
 
 def test_domain_fusion_imperfectly_nested():
@@ -665,8 +665,7 @@ def test_division_in_shapes(ctx_factory):
         """
     t_unit = lp.parse_fortran(fortran_src)
     ref_t_unit = t_unit
-
-    print(t_unit)
+    logger.info("%s", t_unit)
 
     ctx = ctx_factory()
     lp.auto_test_vs_ref(ref_t_unit, ctx, t_unit, parameters={"m": 128})

test/test_isl.py

@@ -20,19 +20,26 @@
 THE SOFTWARE.
 """
 
+import logging
+
 import islpy as isl
 
 
+logger = logging.getLogger(__name__)
+
+
 def test_aff_to_expr():
     s = isl.Space.create_from_names(isl.Context(), ["a", "b"])
     zero = isl.Aff.zero_on_domain(isl.LocalSpace.from_space(s))
     a = zero.set_coefficient_val(isl.dim_type.in_, 0, 1)
     b = zero.set_coefficient_val(isl.dim_type.in_, 1, 1)
 
     x = (5*a + 3*b) % 17 % 5
-    print(x)
+    logger.info("x = %s", x)
+
     from loopy.symbolic import aff_to_expr
-    print(aff_to_expr(x))
+
+    logger.info("%s", aff_to_expr(x))
 
 
 def test_aff_to_expr_2():