From e4466a6551b58f6691986a8bba43ec42283ec283 Mon Sep 17 00:00:00 2001 From: Alexandru Fikl Date: Wed, 19 Feb 2025 10:19:12 +0200 Subject: [PATCH] feat(tests): use logger instead of printing --- test/test_apps.py | 13 ++--- test/test_callables.py | 2 +- test/test_diff.py | 4 +- test/test_domain.py | 15 ++--- test/test_expression.py | 48 +++++++-------- test/test_fortran.py | 7 +-- test/test_isl.py | 11 +++- test/test_loopy.py | 126 ++++++++++++++++++++-------------------- test/test_numa_diff.py | 12 ++-- test/test_reduction.py | 14 ++--- test/test_scan.py | 4 +- test/test_sem_reagan.py | 2 +- test/test_statistics.py | 15 ++--- test/test_target.py | 14 ++--- test/test_transform.py | 12 ++-- 15 files changed, 149 insertions(+), 150 deletions(-) diff --git a/test/test_apps.py b/test/test_apps.py index bf86148aa..440e17867 100644 --- a/test/test_apps.py +++ b/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(): diff --git a/test/test_callables.py b/test/test_callables.py index 17289b3bc..248f23d68 100644 --- a/test/test_callables.py +++ b/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): diff --git a/test/test_diff.py b/test/test_diff.py index b1fdc7e86..51c72e4a1 100644 --- a/test/test_diff.py +++ b/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() diff --git a/test/test_domain.py b/test/test_domain.py index 8209777bc..79564a2a1 100644 --- a/test/test_domain.py +++ b/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__": diff --git a/test/test_expression.py b/test/test_expression.py index acb5572f0..24877ba37 100644 --- a/test/test_expression.py +++ b/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() diff --git a/test/test_fortran.py b/test/test_fortran.py index 949f3ac11..ab2a7fa23 100644 --- a/test/test_fortran.py +++ b/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}) diff --git a/test/test_isl.py b/test/test_isl.py index 125fae143..be1351498 100644 --- a/test/test_isl.py +++ b/test/test_isl.py @@ -20,9 +20,14 @@ 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)) @@ -30,9 +35,11 @@ def test_aff_to_expr(): 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(): diff --git a/test/test_loopy.py b/test/test_loopy.py index 8952c5adb..b745687e9 100644 --- a/test/test_loopy.py +++ b/test/test_loopy.py @@ -81,8 +81,7 @@ def test_complicated_subst(ctx_factory): """) knl = lp.expand_subst(knl, "... > id:h and tag:two > id:g and tag:two") - - print(knl) + logger.info("%s", knl) sr_keys = list(knl["loopy_kernel"].substitutions.keys()) for letter, how_many in [ @@ -173,8 +172,8 @@ def test_simple_side_effect(): target=lp.PyOpenCLTarget() ) - print(knl) - print(lp.generate_code_v2(knl)) + logger.info("%s", knl) + logger.info("%s", lp.generate_code_v2(knl)) def test_owed_barriers(): @@ -189,8 +188,8 @@ def test_owed_barriers(): knl = lp.tag_inames(knl, {"i": "l.0"}) - print(knl) - print(lp.generate_code_v2(knl)) + logger.info("%s", knl) + logger.info("%s", lp.generate_code_v2(knl)) def test_multi_cse(): @@ -205,8 +204,8 @@ def test_multi_cse(): knl = lp.split_iname(knl, "i", 16, inner_tag="l.0") knl = lp.add_prefetch(knl, "a", []) - print(knl) - print(lp.generate_code_v2(knl)) + logger.info("%s", knl) + logger.info("%s", lp.generate_code_v2(knl)) def test_bare_data_dependency(ctx_factory): @@ -340,8 +339,8 @@ def test_arg_shape_guessing(): 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()) def test_arg_guessing(): @@ -355,8 +354,8 @@ def test_arg_guessing(): 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()) def test_arg_guessing_with_reduction(): @@ -371,8 +370,8 @@ def test_arg_guessing_with_reduction(): 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()) def test_unknown_arg_shape(): @@ -395,7 +394,7 @@ def test_unknown_arg_shape(): assumptions="m<=%d and m>=1 and n mod %d = 0" % (bsize[0], bsize[0])) knl = lp.add_and_infer_dtypes(knl, {"a": np.float32}) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) # }}} @@ -413,8 +412,8 @@ def test_nonlinear_index(): 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()) def test_offsets_and_slicing(ctx_factory): @@ -448,7 +447,7 @@ def test_offsets_and_slicing(ctx_factory): knl = lp.add_dtypes(knl, {"a": a.dtype}) - print(lp.generate_code_v2(knl)) + logger.info("%s", lp.generate_code_v2(knl)) knl(queue, a=a, b=b) import numpy.linalg as la @@ -496,8 +495,8 @@ def test_c_instruction(): knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0") - print(knl) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", knl) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_dependent_domain_insn_iname_finding(): @@ -519,8 +518,8 @@ def test_dependent_domain_insn_iname_finding(): "..."], target=lp.PyOpenCLTarget(), name="loopy_kernel") + logger.info("%s", prog) - print(prog) assert "isrc_box" in prog["loopy_kernel"].insn_inames("set_strength") prog = lp.add_dtypes(prog, @@ -530,7 +529,7 @@ def test_dependent_domain_insn_iname_finding(): "box_source_counts_nonchild": np.int32, "strengths": np.float64, "nsources": np.int32}) - print(lp.generate_code_v2(prog).device_code()) + logger.info("%s", lp.generate_code_v2(prog).device_code()) def test_inames_deps_from_write_subscript(ctx_factory): @@ -546,8 +545,8 @@ def test_inames_deps_from_write_subscript(ctx_factory): None, shape=None), "..."], name="loopy_kernel") + logger.info("%s", prog) - print(prog) assert "i" in prog["loopy_kernel"].insn_inames("myred") @@ -562,10 +561,10 @@ def test_modulo_indexing(): "..." ], target=lp.PyOpenCLTarget() ) + logger.info("%s", knl) - print(knl) knl = lp.add_dtypes(knl, {"a": np.float32}) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) @pytest.mark.parametrize("vec_len", [2, 3, 4, 8, 16]) @@ -731,17 +730,17 @@ def test_slab_decomposition_does_not_double_execute(ctx_factory): a_knl = a.copy() knl = lp.set_options(knl, write_code=True) - print("TEST-----------------------------------------") + logger.info("TEST-----------------------------------------") knl(queue, a=a_knl) - print("REF-----------------------------------------") + logger.info("REF------------------------------------------") ref_knl(queue, a=a_ref) - print("DONE-----------------------------------------") + logger.info("DONE-----------------------------------------") - print("REF", a_ref) - print("KNL", a_knl) + logger.info("REF: %s", a_ref) + logger.info("KNL: %s", a_knl) assert (a_ref == a_knl).get().all() - print("_________________________________") + logger.info("_____________________________________________") def test_multiple_writes_to_local_temporary(): @@ -756,7 +755,7 @@ def test_multiple_writes_to_local_temporary(): temp[i, 1] = 15 """) knl = lp.tag_inames(knl, {"i": "l.0"}) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_make_copy_kernel(ctx_factory): @@ -932,8 +931,8 @@ def test_atomic_init(dtype): ], silenced_warnings=["write_race(init)"]) knl = lp.split_iname(knl, "i", vec_width, inner_tag="l.0") - print(knl) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", knl) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_within_inames_and_reduction(): @@ -969,7 +968,7 @@ def test_within_inames_and_reduction(): prog = lp.preprocess_kernel(prog) assert "i" not in prog["loopy_kernel"].insn_inames("insn_0_j_update") - print(prog["loopy_kernel"].stringify(with_dependencies=True)) + logger.info("%s", prog["loopy_kernel"].stringify(with_dependencies=True)) def test_literal_local_barrier(ctx_factory): @@ -1033,14 +1032,14 @@ def test_kernel_splitting(ctx_factory): knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0") # map schedule onto host or device - print(knl) + logger.info("%s", knl) cgr = lp.generate_code_v2(knl) assert len(cgr.device_programs) == 2 - print(cgr.device_code()) - print(cgr.host_code()) + logger.info("%s", cgr.device_code()) + logger.info("%s", cgr.host_code()) lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5}) @@ -1067,14 +1066,14 @@ def test_kernel_splitting_with_loop(ctx_factory): knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0") # map schedule onto host or device - print(knl) + logger.info("%s", knl) cgr = lp.generate_code_v2(knl) assert len(cgr.device_programs) == 2 - print(cgr.device_code()) - print(cgr.host_code()) + logger.info("%s", cgr.device_code()) + logger.info("%s", cgr.host_code()) lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5}) @@ -1087,10 +1086,10 @@ def save_and_reload_temporaries_test(queue, prog, out_expect, debug=False): prog.callables_table)) if debug: - print(prog) + logger.info("%s", prog) cgr = lp.generate_code_v2(prog) - print(cgr.device_code()) - print(cgr.host_code()) + logger.info("%s", cgr.device_code()) + logger.info("%s", cgr.host_code()) _, (out,) = prog(queue, out_host=True) assert (out == out_expect).all(), (out, out_expect) @@ -1436,8 +1435,8 @@ def test_global_temporary(ctx_factory): assert len(cgr.device_programs) == 2 - print(cgr.device_code()) - # print(cgr.host_code()) + logger.info("%s", cgr.device_code()) + # logger.info("%s", cgr.host_code()) lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"n": 5}) @@ -1551,7 +1550,7 @@ def test_call_with_options(): from library_for_test import NoRetFunction knl = lp.register_callable(knl, "f", NoRetFunction("f")) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) # }}} @@ -1628,7 +1627,7 @@ def test_sequential_dependencies(ctx_factory): end """, seq_dependencies=True) - print(prog["loopy_kernel"].stringify(with_dependencies=True)) + logger.info("%s", prog["loopy_kernel"].stringify(with_dependencies=True)) lp.auto_test_vs_ref(prog, ctx, prog, parameters={"n": 5}) @@ -1647,7 +1646,7 @@ def test_nop(ctx_factory): end """) - print(knl) + logger.info("%s", knl) knl = lp.fix_parameters(knl, n=15) knl = lp.add_and_infer_dtypes(knl, {"z": np.float64}) @@ -1682,7 +1681,7 @@ def test_global_barrier(ctx_factory): ref_knl = lp.set_temporary_address_space(ref_knl, "v", "global") knl = lp.split_iname(knl, "i", 256, outer_tag="g.0", inner_tag="l.0") - print(knl) + logger.info("%s", knl) knl = lp.preprocess_kernel(knl) assert ( @@ -1692,7 +1691,7 @@ def test_global_barrier(ctx_factory): knl["loopy_kernel"].temporary_variables["v"].address_space == lp.AddressSpace.GLOBAL) - print(knl) + logger.info("%s", knl) lp.auto_test_vs_ref(ref_knl, ctx, knl, parameters={"ntrips": 5, "n": 10}) @@ -1734,7 +1733,7 @@ def test_index_cse(ctx_factory): knl = lp.prioritize_loops(knl, "i,j,k,l") knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32}) knl = lp.fix_parameters(knl, n=5) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_ilp_and_conditionals(ctx_factory): @@ -2045,8 +2044,6 @@ def test_tight_loop_bounds_codegen(): knl = lp.split_iname(knl, "i", 5, inner_tag="l.0", outer_tag="g.0") cgr = lp.generate_code_v2(knl) - # print(cgr.device_code()) - for_loop = \ "for (int j = " \ "((gid(0) == 0 && lid(0) == 0) ? 0 : -2 + 2 * lid(0) + 10 * gid(0)); " \ @@ -2177,7 +2174,8 @@ def test_nosync_option_parsing(): """, options=lp.Options(allow_terminal_colors=False)) kernel_str = str(knl) - print(kernel_str) + logger.info("%s", kernel_str) + assert "id=insn1, no_sync_with=insn1@any" in kernel_str assert "id=insn2, no_sync_with=insn1@any:insn2@any" in kernel_str assert "id=insn3, no_sync_with=insn1@local:insn2@global:insn3@any" in kernel_str @@ -2241,7 +2239,7 @@ def test_barrier_insertion_near_top_of_loop(): prog = lp.preprocess_kernel(prog) knl = lp.get_one_linearized_kernel(prog["loopy_kernel"], prog.callables_table) - print(knl) + logger.info("%s", knl) assert barrier_between(knl, "ainit", "tcomp") @@ -2267,7 +2265,7 @@ def test_barrier_insertion_near_bottom_of_loop(): prog = lp.preprocess_kernel(prog) knl = lp.get_one_linearized_kernel(prog["loopy_kernel"], prog.callables_table) - print(knl) + logger.info("%s", knl) assert barrier_between(knl, "bcomp1", "bcomp2") assert barrier_between(knl, "ainit", "aupdate", ignore_barriers_in_levels=[1]) @@ -2662,7 +2660,7 @@ def test_dep_cycle_printing_and_error(): from loopy.diagnostic import DependencyCycleFound with pytest.raises(DependencyCycleFound): - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_backwards_dep_printing_and_error(): @@ -2681,7 +2679,7 @@ def test_backwards_dep_printing_and_error(): ]) # Used to crash with KeyError - print(knl) + logger.info("%s", knl) def test_dump_binary(ctx_factory): @@ -2810,7 +2808,7 @@ def test_type_inference_walks_fn_in_comparison(): ], target=lp.CTarget()) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_non_integral_array_idx_raises(): @@ -2823,7 +2821,7 @@ def test_non_integral_array_idx_raises(): from loopy.diagnostic import LoopyError with pytest.raises(LoopyError): - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) @pytest.mark.parametrize("tag", ["for", "l.0", "g.0", "fixed"]) @@ -2901,7 +2899,7 @@ def test_access_check_with_insn_predicates(): end """, [lp.GlobalArg("x", dtype=float, shape=(4,)), ...]) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_conditional_access_range_with_parameters(ctx_factory): @@ -3040,7 +3038,7 @@ def test_deps_from_conditionals(): # Ensure valid linearization exists: No valid linearization unless the # accumulator initializers can move out of the loop. - print(lp.generate_code_v2(ppknl).device_code()) + logger.info("%s", lp.generate_code_v2(ppknl).device_code()) def test_scalar_temporary(ctx_factory): @@ -3488,7 +3486,7 @@ def test_global_temps_with_multiple_base_storages(ctx_factory): prg = lp.infer_unknown_types(prg) prg = lp.allocate_temporaries_for_base_storage(prg) - print(prg) + logger.info("%s", prg) _, (out,) = prg(cq) diff --git a/test/test_numa_diff.py b/test/test_numa_diff.py index da7b4387d..6d7e91f5e 100644 --- a/test/test_numa_diff.py +++ b/test/test_numa_diff.py @@ -133,7 +133,7 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level): # noqa: ("sknl", sflux_insn, ("i", "n",), stmps, ("ii", "jj",)), ]: flux_var, = insn.assignee_var_names() - print(insn) + logger.info("insn %s", insn) reader, = lp.find_instructions(hsv, "tag:{knl_tag} and reads:{flux_var}" @@ -246,13 +246,13 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level): # noqa: "-cl-no-signed-zeros"]) if 1: - print("OPS") + logger.info("OPS") op_map = lp.get_op_map(hsv, subgroup_size=32) - print(op_map) + logger.info("%s", op_map) - print("MEM") + logger.info("MEM") gmem_map = lp.get_mem_access_map(hsv, subgroup_size=32).to_bytes() - print(gmem_map) + logger.info("%s", gmem_map) # FIXME: renaming's a bit tricky in this program model. # add a simple transformation for it @@ -263,7 +263,7 @@ def test_gnuma_horiz_kernel(ctx_factory, ilp_multiple, Nq, opt_level): # noqa: elapsed = results["elapsed_wall"] - print("elapsed", elapsed) + logger.info("elapsed: %g", elapsed) if __name__ == "__main__": diff --git a/test/test_reduction.py b/test/test_reduction.py index 09c09a04b..3c6aa585e 100644 --- a/test/test_reduction.py +++ b/test/test_reduction.py @@ -69,7 +69,7 @@ def test_empty_reduction(ctx_factory): ) knl = lp.preprocess_kernel(knl) - print(knl) + logger.info("%s", knl) knl = lp.set_options(knl, write_code=True) _evt, (a,) = knl(queue) @@ -132,7 +132,7 @@ def test_multi_nested_dependent_reduction(): assumptions="ntgts>=1", target=lp.PyOpenCLTarget()) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) # FIXME: Actually test functionality. @@ -164,7 +164,7 @@ def test_recursive_nested_dependent_reduction(): assumptions="ntgts>=1", target=lp.PyOpenCLTarget()) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) # FIXME: Actually test functionality. @@ -292,9 +292,9 @@ def test_argmax(ctx_factory): """ max_val, max_idx = argmax(i, abs(a[i]), i) """) - knl = lp.add_and_infer_dtypes(knl, {"a": np.float32}) - print(lp.preprocess_kernel(knl)) + logger.info("%s", lp.preprocess_kernel(knl)) + knl = lp.set_options(knl, write_code=True, allow_terminal_colors=True) a = rng.normal(size=10000).astype(np.float32) @@ -378,7 +378,7 @@ def test_double_sum_made_unique(ctx_factory): assumptions="n>=1") knl = lp.make_reduction_inames_unique(knl) - print(knl) + logger.info("%s", knl) _evt, (a, b) = knl(queue, n=n) @@ -423,7 +423,7 @@ def test_reduction_with_conditional(): knl = lp.tag_inames(knl, "l:g.0") knl = lp.add_and_infer_dtypes(knl, {"a": np.float32}) code = lp.generate_code_v2(knl).device_code() - print(code) + logger.info("%s", code) # Check that the if appears before the loop that realizes the reduction. assert code.index("if") < code.index("for") diff --git a/test/test_scan.py b/test/test_scan.py index f9d55aa9a..23e8bf674 100644 --- a/test/test_scan.py +++ b/test/test_scan.py @@ -174,11 +174,11 @@ def test_nested_scan(ctx_factory, i_tag, j_tag): knl = lp.realize_reduction(knl, force_scan=True) - print(knl) + logger.info("%s", knl) _evt, (out,) = knl(queue) - print(out) + logger.info("%s", out) def test_scan_not_triangular(): diff --git a/test/test_sem_reagan.py b/test/test_sem_reagan.py index 602549a68..5dd6f5b38 100644 --- a/test/test_sem_reagan.py +++ b/test/test_sem_reagan.py @@ -102,7 +102,7 @@ def variant_orig(knl): knl = lp.tag_inames(knl, {"m": "unr"}) knl = lp.set_instruction_priority(knl, "id:D_fetch", 5) - print(knl) + logger.info("%s", knl) return knl diff --git a/test/test_statistics.py b/test/test_statistics.py index ce3f0d0f9..6d66c2d96 100644 --- a/test/test_statistics.py +++ b/test/test_statistics.py @@ -227,7 +227,8 @@ def test_op_counter_bitwise(): m = 256 ell = 128 params = {"n": n, "m": m, "ell": ell} - print(op_map) + logger.info("%s", op_map) + i32add = op_map[ lp.Op(np.int32, "add", CG.SUBGROUP, "bitwise") ].eval_with_dict(params) @@ -1030,7 +1031,8 @@ def test_barrier_counter_barriers(): knl = lp.add_and_infer_dtypes(knl, {"a": np.int32}) knl = lp.split_iname(knl, "k", 128, inner_tag="l.0") sync_map = lp.get_synchronization_map(knl) - print(sync_map) + logger.info("%s", sync_map) + n = 512 m = 256 ell = 128 @@ -1049,7 +1051,8 @@ def test_barrier_count_single(): knl = lp.tag_inames(knl, {"i": "l.0"}) sync_map = lp.get_synchronization_map(knl) - print(sync_map) + logger.info("%s", sync_map) + barrier_count = sync_map.filter_by(kind="barrier_local").eval_and_sum() assert barrier_count == 1 @@ -1288,7 +1291,7 @@ def test_gather_access_footprint(): fp = gather_access_footprints(knl) for key, footprint in fp.items(): - print(key, count(knl, footprint)) + logger.info("key %s count %d", key, count(knl, footprint)) def test_gather_access_footprint_2(): @@ -1304,7 +1307,7 @@ def test_gather_access_footprint_2(): params = {"n": 200} for key, footprint in fp.items(): assert count(knl, footprint).eval_with_dict(params) == 200 - print(key, count(knl, footprint)) + logger.info("key %s count %d", key, count(knl, footprint)) def test_summations_and_filters(): @@ -1373,8 +1376,6 @@ def test_summations_and_filters(): op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True, count_within_subscripts=True) - # for k, v in op_map.items(): - # print(type(k), "\n", k.name, k.dtype, type(k.dtype), " :\n", v) op_map_dtype = op_map.group_by("dtype") f32 = op_map_dtype[lp.Op(dtype=np.float32)].eval_with_dict(params) diff --git a/test/test_target.py b/test/test_target.py index 32ca21ed5..330f49eab 100644 --- a/test/test_target.py +++ b/test/test_target.py @@ -64,8 +64,8 @@ def test_ispc_target(): codegen_result = lp.generate_code_v2(knl) - print(codegen_result.device_code()) - print(codegen_result.host_code()) + logger.info("%s", codegen_result.device_code()) + logger.info("%s", codegen_result.host_code()) def test_cuda_target(): @@ -85,9 +85,7 @@ def test_cuda_target(): knl = lp.add_prefetch(knl, "a", ["i_inner", "i_outer_inner"], default_tag="l.auto") - print( - lp.generate_code_v2( - knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_generate_c_snippet(): @@ -128,7 +126,7 @@ def test_generate_c_snippet(): knl = lp.split_iname(knl, "k", 4, inner_tag="unr", slabs=(0, 1)) knl = lp.prioritize_loops(knl, "I,k_outer,k_inner") - print(lp.generate_code_v2(knl)) + logger.info("%s", lp.generate_code_v2(knl)) @pytest.mark.parametrize("target", [CTarget, OpenCLTarget]) @@ -322,7 +320,7 @@ def test_cuda_short_vector(): knl = lp.set_options(knl, write_wrapper=True) knl = lp.add_and_infer_dtypes(knl, {"a": np.float32}) - print(lp.generate_code_v2(knl).device_code()) + logger.info("%s", lp.generate_code_v2(knl).device_code()) def test_pyopencl_execution_numpy_handling(ctx_factory): @@ -795,7 +793,7 @@ def test_ispc_private_var(): cg_result = lp.generate_code_v2(knl) - print(cg_result.device_code()) + logger.info("%s", cg_result.device_code()) def test_to_complex_casts(ctx_factory): diff --git a/test/test_transform.py b/test/test_transform.py index a4d04e61d..d9e0cd757 100644 --- a/test/test_transform.py +++ b/test/test_transform.py @@ -233,7 +233,7 @@ def test_fusion(): knl = lp.fuse_kernels([exp_kernel, sum_kernel]) - print(knl) + logger.info("%s", knl) def test_alias_temporaries(ctx_factory): @@ -306,8 +306,7 @@ def test_extract_subst(ctx_factory): """, name="extract_subst") prog = lp.extract_subst(prog, "bsquare", "alpha*b[i]**2", "alpha") - - print(prog) + logger.info("%s", prog) from loopy.symbolic import parse @@ -405,7 +404,7 @@ def test_affine_map_inames(): "i", "i0", "i0 = n+i") - print(knl) + logger.info("%s", knl) def test_precompute_confusing_subst_arguments(ctx_factory): @@ -1402,7 +1401,7 @@ def test_simplify_indices_when_inlining(ctx_factory): inlined_knl = lp.inline_callable_kernel(knl, "zerozerozeroonezeroify") contains_floordiv = ContainsFloorDiv() - print(inlined_knl) + logger.info("%s", inlined_knl) assert all(not contains_floordiv(insn.expression) for insn in inlined_knl.default_entrypoint.instructions @@ -1737,7 +1736,8 @@ def test_duplicate_iname_not_read_only_nested(ctx_factory): t_unit = lp.duplicate_inames( t_unit, inames="i", within="tag:foo", new_inames="irow") - print(t_unit) + logger.info("%s", t_unit) + assert (t_unit.default_entrypoint.id_to_insn["init"].within_inames == frozenset({"irow"}))