diff --git a/loopy/__init__.py b/loopy/__init__.py index 107019022a7ef52ea46165a3ad72039a6e04f487..a9251da3b5ae40d53f8b794f6c9075abf1b89ecb 100644 --- a/loopy/__init__.py +++ b/loopy/__init__.py @@ -111,7 +111,7 @@ from loopy.transform.padding import ( add_padding) from loopy.transform.privatize import privatize_temporaries_with_inames -from loopy.transform.batch import to_batched, save_temporaries_in_loop +from loopy.transform.batch import to_batched from loopy.transform.parameter import assume, fix_parameters from loopy.transform.save import save_and_reload_temporaries from loopy.transform.add_barrier import add_barrier @@ -228,7 +228,7 @@ __all__ = [ "privatize_temporaries_with_inames", - "to_batched", "save_temporaries_in_loop", + "to_batched", "assume", "fix_parameters", diff --git a/test/test_callables.py b/test/test_callables.py index efb1e5e72d697ebf7b249875c46e8aed1297d7ca..62c2a797eaf20f492a167fa00a8fc608f56ea5b8 100644 --- a/test/test_callables.py +++ b/test/test_callables.py @@ -70,13 +70,13 @@ def test_register_knl(ctx_factory, inline): "{[i, j]:0<= i, j< 16}", """ c[i, j] = 2*a[i, j] + 3*b[i, j] - """, name='linear_combo1') + """, name="linear_combo1") child_knl = lp.make_function( "{[i, j]:0<=i, j < 16}", """ [i, j]: g[i, j] = linear_combo1([i, j]: e[i, j], [i, j]: f[i, j]) - """, name='linear_combo2') + """, name="linear_combo2") parent_knl = lp.make_kernel( "{[i, j, k, l, m]: 0<=i, j, k, l, m<16}", @@ -86,13 +86,13 @@ def test_register_knl(ctx_factory, inline): """, kernel_data=[ lp.GlobalArg( - name='x', + name="x", dtype=np.float64, shape=(16, 16, 16, 16, 16)), lp.GlobalArg( - name='y', + name="y", dtype=np.float64, - shape=(16, 16, 16, 16, 16)), '...'], + shape=(16, 16, 16, 16, 16)), ...], ) knl = lp.register_callable_kernel( @@ -100,8 +100,8 @@ def test_register_knl(ctx_factory, inline): knl = lp.register_callable_kernel( knl, grandchild_knl) if inline: - knl = lp.inline_callable_kernel(knl, 'linear_combo2') - knl = lp.inline_callable_kernel(knl, 'linear_combo1') + knl = lp.inline_callable_kernel(knl, "linear_combo2") + knl = lp.inline_callable_kernel(knl, "linear_combo1") evt, (out, ) = knl(queue, x=x, y=y) @@ -132,23 +132,23 @@ def test_slices_with_negative_step(ctx_factory, inline): """, kernel_data=[ lp.GlobalArg( - name='x', + name="x", dtype=np.float64, shape=(16, 16, 16, 16, 16)), lp.GlobalArg( - name='y', + name="y", dtype=np.float64, shape=(16, 16, 16, 16, 16)), lp.GlobalArg( - name='z', + name="z", dtype=np.float64, - shape=(16, 16, 16, 16, 16)), '...'], + shape=(16, 16, 16, 16, 16)), ...], ) knl = lp.register_callable_kernel( parent_knl, child_knl) if inline: - knl = lp.inline_callable_kernel(knl, 'linear_combo') + knl = lp.inline_callable_kernel(knl, "linear_combo") evt, (out, ) = knl(queue, x=x, y=y) @@ -175,8 +175,8 @@ def test_register_knl_with_call_with_kwargs(ctx_factory, inline): p[i, j] = 7 * e[i, j] + 4*f1[i, j] + 2*g[i, j] """, [ - lp.GlobalArg('f, e, h, g'), '...'], - name='linear_combo') + lp.GlobalArg("f, e, h, g"), ...], + name="linear_combo") caller_knl = lp.make_kernel( "{[i, j, k, l, m]: 0<=i, j, k, l, m<%d}" % n, @@ -191,7 +191,7 @@ def test_register_knl_with_call_with_kwargs(ctx_factory, inline): knl = lp.register_callable_kernel( caller_knl, callee_knl) if inline: - knl = lp.inline_callable_kernel(knl, 'linear_combo') + knl = lp.inline_callable_kernel(knl, "linear_combo") evt, (out1, out2, ) = knl(queue, a=a_dev, b=b_dev, c=c_dev) @@ -222,7 +222,7 @@ def test_register_knl_with_hw_axes(ctx_factory, inline): "{[i, j]:0<=i, j < 32}", """ g[i, j] = 2*e[i, j] + 3*f[i, j] - """, name='linear_combo') + """, name="linear_combo") callee_knl = lp.split_iname(callee_knl, "i", 2, inner_tag="l.0", outer_tag="g.0") @@ -238,12 +238,12 @@ def test_register_knl_with_hw_axes(ctx_factory, inline): knl = lp.register_callable_kernel( caller_knl, callee_knl) - knl = lp.set_options(knl, 'return_dict') + knl = lp.set_options(knl, "return_dict") gsize, lsize = knl.get_grid_size_upper_bounds_as_exprs() if inline: - knl = lp.inline_callable_kernel(knl, 'linear_combo') + knl = lp.inline_callable_kernel(knl, "linear_combo") evt, out = knl(queue, x=x_dev, y=y_dev) @@ -252,7 +252,7 @@ def test_register_knl_with_hw_axes(ctx_factory, inline): assert gsize == (16, 4) assert lsize == (2, 8) - assert np.linalg.norm(2*x_host+3*y_host-out['z'].get())/np.linalg.norm( + assert np.linalg.norm(2*x_host+3*y_host-out["z"].get())/np.linalg.norm( 2*x_host+3*y_host) < 1e-15 @@ -296,17 +296,17 @@ def test_shape_translation_through_sub_array_ref(ctx_factory, inline): knl = lp.register_callable_kernel(knl, callee3) if inline: - knl = lp.inline_callable_kernel(knl, 'callee_fn1') - knl = lp.inline_callable_kernel(knl, 'callee_fn2') - knl = lp.inline_callable_kernel(knl, 'callee_fn3') + knl = lp.inline_callable_kernel(knl, "callee_fn1") + knl = lp.inline_callable_kernel(knl, "callee_fn2") + knl = lp.inline_callable_kernel(knl, "callee_fn3") knl = lp.set_options(knl, "write_cl") knl = lp.set_options(knl, "return_dict") evt, out_dict = knl(queue, x1=x1, x2=x2, x3=x3) - y1 = out_dict['y1'].get() - y2 = out_dict['y2'].get() - y3 = out_dict['y3'].get() + y1 = out_dict["y1"].get() + y2 = out_dict["y2"].get() + y3 = out_dict["y3"].get() assert (np.linalg.norm(y1-2*x1.get())) < 1e-15 assert (np.linalg.norm(y2-3*x2.get())) < 1e-15 @@ -353,8 +353,8 @@ def test_multi_arg_array_call(ctx_factory): evt, out_dict = knl(queue, b=b) tol = 1e-15 from numpy.linalg import norm - assert(norm(out_dict['min_val'][0] - np.min(b)) < tol) - assert(norm(out_dict['min_index'][0] - np.argmin(b)) < tol) + assert(norm(out_dict["min_val"][0] - np.min(b)) < tol) + assert(norm(out_dict["min_index"][0] - np.argmin(b)) < tol) @pytest.mark.parametrize("inline", [False, True]) @@ -387,19 +387,19 @@ def test_packing_unpacking(ctx_factory, inline): knl = lp.register_callable_kernel(knl, callee1) knl = lp.register_callable_kernel(knl, callee2) - knl = lp.pack_and_unpack_args_for_call(knl, 'callee_fn1') - knl = lp.pack_and_unpack_args_for_call(knl, 'callee_fn2') + knl = lp.pack_and_unpack_args_for_call(knl, "callee_fn1") + knl = lp.pack_and_unpack_args_for_call(knl, "callee_fn2") if inline: - knl = lp.inline_callable_kernel(knl, 'callee_fn1') - knl = lp.inline_callable_kernel(knl, 'callee_fn2') + knl = lp.inline_callable_kernel(knl, "callee_fn1") + knl = lp.inline_callable_kernel(knl, "callee_fn2") knl = lp.set_options(knl, "write_cl") knl = lp.set_options(knl, "return_dict") evt, out_dict = knl(queue, x1=x1, x2=x2) - y1 = out_dict['y1'].get() - y2 = out_dict['y2'].get() + y1 = out_dict["y1"].get() + y2 = out_dict["y2"].get() assert np.linalg.norm(2*x1.get()-y1)/np.linalg.norm( 2*x1.get()) < 1e-15 @@ -425,7 +425,7 @@ def test_non_sub_array_refs_arguments(ctx_factory): caller3 = lp.make_kernel("{[j] : 0 <= j < 2}", "a[:]=callee(a[:], kappa)", [lp.GlobalArg("a", dtype="double", shape=(6, ), - is_output_only=False), '...'], + is_output_only=False), ...], name="caller", target=lp.CTarget()) registered = lp.register_callable_kernel(caller1, callee) @@ -461,13 +461,13 @@ def test_empty_sub_array_refs(ctx_factory, inline): """ a[d] = b[d] - c[d] - """, name='wence_function') + """, name="wence_function") caller = lp.make_kernel("{[i]: 0<=i<10}", """ []:z[i] = wence_function([]:x[i], []:y[i]) """, - [lp.GlobalArg('x, y', dtype=np.float64, shape=(10, )), '...']) + [lp.GlobalArg("x, y", dtype=np.float64, shape=(10, )), ...]) caller = lp.register_callable_kernel(caller, callee) @@ -500,23 +500,23 @@ def test_array_inputs_to_callee_kernels(ctx_factory, inline): """, kernel_data=[ lp.GlobalArg( - name='x', + name="x", dtype=np.float64, shape=(16, 16)), lp.GlobalArg( - name='y', + name="y", dtype=np.float64, shape=(16, 16)), lp.GlobalArg( - name='z', + name="z", dtype=np.float64, - shape=(16, 16)), '...'], + shape=(16, 16)), ...], ) knl = lp.register_callable_kernel( parent_knl, child_knl) if inline: - knl = lp.inline_callable_kernel(knl, 'linear_combo') + knl = lp.inline_callable_kernel(knl, "linear_combo") evt, (out, ) = knl(queue, x=x, y=y) @@ -529,16 +529,16 @@ def test_stride_depending_on_args(): "{[i, j]: 0<=i, j < n}", """ b[i, j] = 2*a[i, j] - """, [lp.ValueArg('n'), lp.GlobalArg('a'), lp.GlobalArg('b')], - name='twice') + """, [lp.ValueArg("n"), lp.GlobalArg("a"), lp.GlobalArg("b")], + name="twice") thrice = lp.make_function( "{[i, j]: 0<=i, j < n}", """ b[i, j] = 3*a[i, j] - """, [lp.ValueArg('n'), lp.GlobalArg('a', shape=lp.auto), - lp.GlobalArg('b', shape=lp.auto)], - name='thrice') + """, [lp.ValueArg("n"), lp.GlobalArg("a", shape=lp.auto), + lp.GlobalArg("b", shape=lp.auto)], + name="thrice") prog = lp.make_kernel( "{[i0,i1,i2,i3,i4,i5,i6,i7]: 0<=i0, i1, i2, i3, i4, i5, i6, i7< N}", @@ -546,8 +546,8 @@ def test_stride_depending_on_args(): [i0, i1]: y[i0, i1] = twice(N, [i2, i3]: x[2*i2, i3]) [i4, i5]: z[i4, i5] = thrice(N, [i6, i7]: x[2*i6+1, i7]) """, [ - lp.ValueArg('N', dtype=np.int32), lp.GlobalArg('x', - shape=lp.auto, dtype=np.float64), '...']) + lp.ValueArg("N", dtype=np.int32), lp.GlobalArg("x", + shape=lp.auto, dtype=np.float64), ...]) prog = lp.register_callable_kernel(prog, twice) prog = lp.register_callable_kernel(prog, thrice) @@ -561,17 +561,17 @@ def test_unknown_stride_to_callee(): "{[i, j]: 0<=i, j < n}", """ b[i, j] = 2*a[i, j] - """, [lp.ValueArg('n'), lp.GlobalArg('a'), lp.GlobalArg('b')], - name='twice') + """, [lp.ValueArg("n"), lp.GlobalArg("a"), lp.GlobalArg("b")], + name="twice") prog = lp.make_kernel( "{[i,i0,i1,i2,i3]: 0<=i0, i1, i2, i3< N and 0<=i a[j] = j {inames=i:j} - """) - - prog = lp.save_temporaries_in_loop(prog, 'i', ['a']) - assert prog.root_kernel.temporary_variables['a'].shape == (4, 4) - - def test_add_barrier(ctx_factory): ctx = ctx_factory() queue = cl.CommandQueue(ctx) diff --git a/test/testlib.py b/test/testlib.py index 2d2a535fb2369e526c4b9304a60d680763cd8461..5f9b68893c913ca72bfcd027b91116e72abf4973 100644 --- a/test/testlib.py +++ b/test/testlib.py @@ -149,7 +149,7 @@ class Log2Callable(lp.ScalarCallable): dtype = arg_id_to_dtype[0].numpy_dtype - if dtype.kind in ('u', 'i'): + if dtype.kind in ("u", "i"): # ints and unsigned casted to float32 dtype = np.float32 @@ -171,8 +171,8 @@ class Log2Callable(lp.ScalarCallable): def register_log2_lookup(target, identifier): - if identifier == 'log2': - return Log2Callable(name='log2') + if identifier == "log2": + return Log2Callable(name="log2") return None # }}}