migrate test suite

tests/test_simplification_strategy.py → tests/frontend/test_simplification_strategy.py

 import sympy as sp
+import pytest
 
 import pystencils as ps
 from pystencils import Assignment, AssignmentCollection
-from pystencils.sympyextensions import (
+from pystencils.simp import (
     SimplificationStrategy, apply_on_all_subexpressions,
     subexpression_substitution_in_existing_subexpressions)
 
@@ -47,6 +48,8 @@ def test_simplification_strategy():
 
 
 def test_split_inner_loop():
+    pytest.skip("Loop splitting not implemented yet")
+
     dst = ps.fields('dst(8): double[2D]')
     s = sp.symbols('s_:8')
     x = sp.symbols('x')

tests/test_simplifications.py → tests/frontend/test_simplifications.py

@@ -6,7 +6,7 @@ import sympy as sp
 import pystencils as ps
 
 from pystencils import Assignment, AssignmentCollection, fields
-from pystencils.sympyextensions.simplifications import (
+from pystencils.simp import (
     subexpression_substitution_in_main_assignments,
     add_subexpressions_for_divisions,
     add_subexpressions_for_sums,
@@ -150,34 +150,35 @@ def test_add_subexpressions_for_field_reads():
     assert ac3.subexpressions[0].lhs.dtype == create_type("float32")
 
 
-@pytest.mark.parametrize('target', (ps.Target.CPU, ps.Target.GPU))
-@pytest.mark.parametrize('dtype', ('float32', 'float64'))
-@pytest.mark.skipif((vs.major, vs.minor, vs.micro) == (3, 8, 2), reason="does not work on python 3.8.2 for some reason")
-def test_sympy_optimizations(target, dtype):
-    if target == ps.Target.GPU:
-        pytest.importorskip("cupy")
-    src, dst = ps.fields(f'src, dst:  {dtype}[2d]')
+#   TODO: What does this test mean to accomplish?
+# @pytest.mark.parametrize('target', (ps.Target.CPU, ps.Target.GPU))
+# @pytest.mark.parametrize('dtype', ('float32', 'float64'))
+# @pytest.mark.skipif((vs.major, vs.minor, vs.micro) == (3, 8, 2), reason="does not work on python 3.8.2 for some reason")
+# def test_sympy_optimizations(target, dtype):
+#     if target == ps.Target.GPU:
+#         pytest.importorskip("cupy")
+#     src, dst = ps.fields(f'src, dst:  {dtype}[2d]')
 
-    assignments = ps.AssignmentCollection({
-        src[0, 0]: 1.0 * (sp.exp(dst[0, 0]) - 1)
-    })
+#     assignments = ps.AssignmentCollection({
+#         src[0, 0]: 1.0 * (sp.exp(dst[0, 0]) - 1)
+#     })
 
-    config = pystencils.config.CreateKernelConfig(target=target, default_dtype=dtype)
-    ast = ps.create_kernel(assignments, config=config)
+#     config = pystencils.config.CreateKernelConfig(target=target, default_dtype=dtype)
+#     ast = ps.create_kernel(assignments, config=config)
 
-    ps.show_code(ast)
+#     ps.show_code(ast)
 
-    code = ps.get_code_str(ast)
-    if dtype == 'float32':
-        assert 'expf(' in code
-    elif dtype == 'float64':
-        assert 'exp(' in code
+#     code = ps.get_code_str(ast)
+#     if dtype == 'float32':
+#         assert 'expf(' in code
+#     elif dtype == 'float64':
+#         assert 'exp(' in code
 
 
 @pytest.mark.parametrize('target', (ps.Target.CPU, ps.Target.GPU))
-@pytest.mark.parametrize('simplification', (True, False))
 @pytest.mark.skipif((vs.major, vs.minor, vs.micro) == (3, 8, 2), reason="does not work on python 3.8.2 for some reason")
-def test_evaluate_constant_terms(target, simplification):
+@pytest.mark.xfail(reason="The new backend does not (yet) evaluate transcendental functions")
+def test_evaluate_constant_terms(target):
     if target == ps.Target.GPU:
         pytest.importorskip("cupy")
     src, dst = ps.fields('src, dst:  float32[2d]')
@@ -187,7 +188,7 @@ def test_evaluate_constant_terms(target, simplification):
         src[0, 0]: -sp.cos(1) + dst[0, 0]
     })
 
-    config = pystencils.config.CreateKernelConfig(target=target, default_assignment_simplifications=simplification)
+    config = pystencils.config.CreateKernelConfig(target=target)
     ast = ps.create_kernel(assignments, config=config)
     code = ps.get_code_str(ast)
-    assert 'cos(' not in code
+    assert 'cos(' not in code and 'cosf(' not in code

tests/test_blocking.py → tests/kernelcreation/test_blocking.py

 import numpy as np
 import sympy as sp
+import pytest
 
 import pystencils as ps
 
@@ -39,6 +40,7 @@ def check_equivalence(assignments, src_arr):
             np.testing.assert_almost_equal(ref_arr, dst3_arr)
 
 
+@pytest.mark.xfail(reason="CPU blocking is not yet implemented in the new backend")
 def test_jacobi3d_var_size():
     src, dst = ps.fields("src, dst: double[3D]", layout='c')
 
@@ -55,6 +57,7 @@ def test_jacobi3d_var_size():
     check_equivalence(jacobi(dst, src), arr)
 
 
+@pytest.mark.xfail(reason="CPU blocking is not yet implemented in the new backend")
 def test_jacobi3d_fixed_size():
     print("Fixed Size: Large non divisible sizes")
     arr = np.empty([10, 10, 9])
@@ -72,6 +75,7 @@ def test_jacobi3d_fixed_size():
     check_equivalence(jacobi(dst, src), arr)
 
 
+@pytest.mark.xfail(reason="CPU blocking is not yet implemented in the new backend")
 def test_jacobi3d_fixed_field_size():
     src, dst = ps.fields("src, dst: double[3, 5, 6]", layout='c')
 

tests/test_blocking_staggered.py → tests/kernelcreation/test_blocking_staggered.py

 import numpy as np
+import pytest
 
 import pystencils as ps
 
 
+@pytest.mark.xfail(reason="Blocking and staggered accesses are not yet implemented in the new backend")
 def test_blocking_staggered():
     f = ps.fields("f: double[3D]")
     stag = ps.fields("stag(3): double[3D]", field_type=ps.FieldType.STAGGERED)

tests/test_buffer.py → tests/kernelcreation/test_buffer.py

@@ -193,6 +193,7 @@ def test_field_layouts():
             unpack_kernel = unpack_code.compile()
             unpack_kernel(buffer=bufferArr, dst_field=dst_arr)
 
+
 def test_iteration_slices():
     num_cell_values = 19
     dt = np.uint64
@@ -244,5 +245,3 @@ def test_iteration_slices():
         np.testing.assert_equal(dst_arr[pack_slice], src_arr[pack_slice])
         np.testing.assert_equal(dst_arr[(slice(1, None, 2),) * (dim - 1) + (0,)], 0)
         np.testing.assert_equal(dst_arr[(slice(None, None, 1),) * (dim - 1) + (slice(1, None),)], 0)
-
-# test_all_cell_values()
\ No newline at end of file

tests/test_buffer_gpu.py → tests/kernelcreation/test_buffer_gpu.py

@@ -57,18 +57,16 @@ def test_full_scalar_field():
                                       field_type=FieldType.BUFFER, dtype=src_arr.dtype)
 
         pack_eqs = [Assignment(buffer.center(), src_field.center())]
-        pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
 
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         pack_ast = create_kernel(pack_eqs, config=config)
 
         pack_kernel = pack_ast.compile()
         pack_kernel(buffer=gpu_buffer_arr, src_field=gpu_src_arr)
 
         unpack_eqs = [Assignment(dst_field.center(), buffer.center())]
-        unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
 
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         unpack_ast = create_kernel(unpack_eqs, config=config)
 
         unpack_kernel = unpack_ast.compile()
@@ -95,9 +93,8 @@ def test_field_slice():
                                           field_type=FieldType.BUFFER, dtype=src_arr.dtype)
 
             pack_eqs = [Assignment(buffer.center(), src_field.center())]
-            pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
 
-            config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+            config = CreateKernelConfig(target=pystencils.Target.GPU)
             pack_ast = create_kernel(pack_eqs, config=config)
 
             pack_kernel = pack_ast.compile()
@@ -105,9 +102,8 @@ def test_field_slice():
 
             # Unpack into ghost layer of dst_field in N direction
             unpack_eqs = [Assignment(dst_field.center(), buffer.center())]
-            unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
 
-            config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+            config = CreateKernelConfig(target=pystencils.Target.GPU)
             unpack_ast = create_kernel(unpack_eqs, config=config)
 
             unpack_kernel = unpack_ast.compile()
@@ -125,7 +121,7 @@ def test_all_cell_values():
     for (src_arr, gpu_src_arr, gpu_dst_arr, gpu_buffer_arr) in fields:
         src_field = Field.create_from_numpy_array("src_field", gpu_src_arr, index_dimensions=1)
         dst_field = Field.create_from_numpy_array("dst_field", gpu_src_arr, index_dimensions=1)
-        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_dimensions=1,
+        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_shape=(num_cell_values,),
                                       field_type=FieldType.BUFFER, dtype=gpu_src_arr.dtype)
 
         pack_eqs = []
@@ -135,9 +131,7 @@ def test_all_cell_values():
             eq = Assignment(buffer(idx), src_field(idx))
             pack_eqs.append(eq)
 
-        pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         pack_code = create_kernel(pack_eqs, config=config)
         pack_kernel = pack_code.compile()
 
@@ -149,9 +143,7 @@ def test_all_cell_values():
             eq = Assignment(dst_field(idx), buffer(idx))
             unpack_eqs.append(eq)
 
-        unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         unpack_ast = create_kernel(unpack_eqs, config=config)
         unpack_kernel = unpack_ast.compile()
         unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr)
@@ -170,7 +162,7 @@ def test_subset_cell_values():
     for (src_arr, gpu_src_arr, gpu_dst_arr, gpu_buffer_arr) in fields:
         src_field = Field.create_from_numpy_array("src_field", gpu_src_arr, index_dimensions=1)
         dst_field = Field.create_from_numpy_array("dst_field", gpu_src_arr, index_dimensions=1)
-        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_dimensions=1,
+        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_shape=(len(cell_indices),),
                                       field_type=FieldType.BUFFER, dtype=gpu_src_arr.dtype)
 
         pack_eqs = []
@@ -181,7 +173,7 @@ def test_subset_cell_values():
             pack_eqs.append(eq)
 
         pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         pack_ast = create_kernel(pack_eqs, config=config)
         pack_kernel = pack_ast.compile()
         pack_kernel(buffer=gpu_buffer_arr, src_field=gpu_src_arr)
@@ -193,7 +185,7 @@ def test_subset_cell_values():
             unpack_eqs.append(eq)
 
         unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-        config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+        config = CreateKernelConfig(target=pystencils.Target.GPU)
         unpack_ast = create_kernel(unpack_eqs, config=config)
         unpack_kernel = unpack_ast.compile()
 
@@ -212,7 +204,7 @@ def test_field_layouts():
         for (src_arr, gpu_src_arr, gpu_dst_arr, gpu_buffer_arr) in fields:
             src_field = Field.create_from_numpy_array("src_field", gpu_src_arr, index_dimensions=1)
             dst_field = Field.create_from_numpy_array("dst_field", gpu_src_arr, index_dimensions=1)
-            buffer = Field.create_generic("buffer", spatial_dimensions=1, index_dimensions=1,
+            buffer = Field.create_generic("buffer", spatial_dimensions=1, index_shape=(num_cell_values,),
                                           field_type=FieldType.BUFFER, dtype=src_arr.dtype)
 
             pack_eqs = []
@@ -223,7 +215,7 @@ def test_field_layouts():
                 pack_eqs.append(eq)
 
             pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-            config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+            config = CreateKernelConfig(target=pystencils.Target.GPU)
             pack_ast = create_kernel(pack_eqs, config=config)
             pack_kernel = pack_ast.compile()
 
@@ -236,13 +228,14 @@ def test_field_layouts():
                 unpack_eqs.append(eq)
 
             unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
-            config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+            config = CreateKernelConfig(target=pystencils.Target.GPU)
             unpack_ast = create_kernel(unpack_eqs, config=config)
             unpack_kernel = unpack_ast.compile()
 
             unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr)
 
 
+@pytest.mark.xfail(reason="flag_cond is not available yet")
 def test_buffer_indexing():
     src_field, dst_field = fields(f'pdfs_src(19), pdfs_dst(19) :double[3D]')
     mask_field = fields(f'mask : uint32 [3D]')
@@ -256,7 +249,7 @@ def test_buffer_indexing():
     up = Assignment(buffer(0), flag_cond(1, mask_field.center, src_field[0, 1, 0](1)))
     iteration_slice = tuple(slice(None, None, 2) for _ in range(3))
     config = CreateKernelConfig(target=Target.GPU)
-    config = replace(config, iteration_slice=iteration_slice, ghost_layers=0)
+    config = replace(config, iteration_slice=iteration_slice)
 
     ast = create_kernel(up, config=config)
     parameters = ast.get_parameters()
@@ -277,13 +270,16 @@ def test_buffer_indexing():
 
 @pytest.mark.parametrize('gpu_indexing', ("block", "line"))
 def test_iteration_slices(gpu_indexing):
+    if gpu_indexing == "line":
+        pytest.xfail("Line indexing not available yet")
+
     num_cell_values = 19
     dt = np.uint64
     fields = _generate_fields(dt=dt, stencil_directions=num_cell_values)
     for (src_arr, gpu_src_arr, gpu_dst_arr, gpu_buffer_arr) in fields:
         src_field = Field.create_from_numpy_array("src_field", gpu_src_arr, index_dimensions=1)
         dst_field = Field.create_from_numpy_array("dst_field", gpu_src_arr, index_dimensions=1)
-        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_dimensions=1,
+        buffer = Field.create_generic("buffer", spatial_dimensions=1, index_shape=(num_cell_values,),
                                       field_type=FieldType.BUFFER, dtype=src_arr.dtype)
 
         pack_eqs = []
@@ -304,7 +300,6 @@ def test_iteration_slices(gpu_indexing):
         gpu_dst_arr.fill(0)
 
         config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice,
-                                    data_type={'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype},
                                     gpu_indexing=gpu_indexing)
 
         pack_code = create_kernel(pack_eqs, config=config)
@@ -318,7 +313,6 @@ def test_iteration_slices(gpu_indexing):
             unpack_eqs.append(eq)
 
         config = CreateKernelConfig(target=Target.GPU, iteration_slice=pack_slice,
-                                    data_type={'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype},
                                     gpu_indexing=gpu_indexing)
 
         unpack_code = create_kernel(unpack_eqs, config=config)

tests/nbackend/test_functions.py → tests/kernelcreation/test_functions.py

@@ -2,7 +2,10 @@ import sympy as sp
 import numpy as np
 import pytest
 
-from pystencils import create_kernel, CreateKernelConfig, Target, Assignment, Field
+from pystencils import fields, create_kernel, CreateKernelConfig, Target, Assignment, Field
+from pystencils.backend.ast import dfs_preorder
+from pystencils.backend.ast.expressions import PsCall
+
 
 
 def unary_function(name, xp):
@@ -120,3 +123,43 @@ def test_binary_functions(target, function_name, dtype):
     kfunc(inp=inp, inp2=inp2, outp=outp)
 
     xp.testing.assert_allclose(outp, reference, rtol=resolution)
+
+
+@pytest.mark.parametrize('a', [sp.Symbol('a'), fields('a:  float64[2d]').center])
+def test_avoid_pow(a):
+    x = fields('x:  float64[2d]')
+
+    up = Assignment(x.center_vector[0], 2 * a ** 2 / 3)
+    func = create_kernel(up)
+
+    powers = list(dfs_preorder(func.body, lambda n: isinstance(n, PsCall) and "pow" in n.function.name))
+    assert not powers
+
+
+@pytest.mark.xfail(reason="fast_div not available yet")
+def test_avoid_pow_fast_div():
+    x = fields('x:  float64[2d]')
+    a = fields('a:  float64[2d]').center
+
+    up = Assignment(x.center_vector[0], fast_division(1, (a**2)))
+    func = create_kernel(up, config=CreateKernelConfig(target=Target.GPU))
+
+    powers = list(dfs_preorder(func.body, lambda n: isinstance(n, PsCall) and "pow" in n.function.name))
+    assert not powers
+
+
+def test_avoid_pow_move_constants():
+    # At the end of the kernel creation the function move_constants_before_loop will be called
+    # This function additionally contains substitutions for symbols with the same value
+    # Thus it simplifies the equations again
+    x = fields('x:  float64[2d]')
+    a, b, c = sp.symbols("a, b, c")
+
+    up = [Assignment(a, 0.0),
+          Assignment(b, 0.0),
+          Assignment(c, 0.0),
+          Assignment(x.center_vector[0], a**2/18 - a*b/6 - a/18 + b**2/18 + b/18 - c**2/36)]
+    func = create_kernel(up)
+
+    powers = list(dfs_preorder(func.body, lambda n: isinstance(n, PsCall) and "pow" in n.function.name))
+    assert not powers

tests/nbackend/kernelcreation/test_gpu.py → tests/kernelcreation/test_gpu.py

 import pytest
 
 import numpy as np
-import cupy as cp
 import sympy as sp
 from scipy.ndimage import convolve
 
@@ -11,8 +10,8 @@ from pystencils.simp import sympy_cse_on_assignment_list
 from pystencils.slicing import add_ghost_layers, make_slice, remove_ghost_layers, normalize_slice
 
 try:
-    import cupy
-    device_numbers = range(cupy.cuda.runtime.getDeviceCount())
+    import cupy as cp
+    device_numbers = range(cp.cuda.runtime.getDeviceCount())
 except ImportError:
     device_numbers = []
 

tests/kernelcreation/test_kernel_decorator.py

+import numpy as np
+import sympy as sp
+import pystencils as ps
+
+
+def test_kernel_decorator_config():
+    config = ps.CreateKernelConfig()
+    a, b, c = ps.fields(a=np.ones(100), b=np.ones(100), c=np.ones(100))
+
+    @ps.kernel_config(config)
+    def test():
+        a[0] @= b[0] + c[0]
+
+    ps.create_kernel(**test)
+
+
+def test_kernel_decorator2():
+    h = sp.symbols("h")
+    dtype = "float64"
+
+    src, dst = ps.fields(f"src, src_tmp: {dtype}[3D]")
+
+    @ps.kernel
+    def kernel_func():
+        dst[0, 0, 0] @= (src[1, 0, 0] + src[-1, 0, 0]
+                         + src[0, 1, 0] + src[0, -1, 0]
+                         + src[0, 0, 1] + src[0, 0, -1]) / (6 * h ** 2)
+
+    # assignments = ps.assignment_from_stencil(stencil, src, dst, normalization_factor=2)
+    ast = ps.create_kernel(kernel_func)
+
+    _ = ps.get_code_str(ast)