diff --git a/pystencils/__init__.py b/pystencils/__init__.py
index bfe5b3da4a27d3770afa067385381e5d8f3008dd..4b23e64c79dd4ad71bfbd8b34e3a17feb3683a91 100644
--- a/pystencils/__init__.py
+++ b/pystencils/__init__.py
@@ -9,7 +9,7 @@ from .display_utils import get_code_obj, get_code_str, show_code, to_dot
from .field import Field, FieldType, fields
from .config import CreateKernelConfig
from .kernel_decorator import kernel, kernel_config
-from .kernelcreation import create_kernel
+from .kernelcreation import create_kernel, create_staggered_kernel
from .simp import AssignmentCollection
from .slicing import make_slice
from .spatial_coordinates import x_, x_staggered, x_staggered_vector, x_vector, y_, y_staggered, z_, z_staggered
@@ -19,7 +19,7 @@ __all__ = ['Field', 'FieldType', 'fields',
'TypedSymbol',
'make_slice',
'CreateKernelConfig',
- 'create_kernel',
+ 'create_kernel', 'create_staggered_kernel',
'Target', 'Backend',
'show_code', 'to_dot', 'get_code_obj', 'get_code_str',
'AssignmentCollection',
diff --git a/pystencils/boundaries/boundaryconditions.py b/pystencils/boundaries/boundaryconditions.py
index c53d248aca3353f57ebf423c30e753af35f1ce81..65243177dafe6dbce44cfb14bf7f1eb5c53fa39c 100644
--- a/pystencils/boundaries/boundaryconditions.py
+++ b/pystencils/boundaries/boundaryconditions.py
@@ -1,6 +1,6 @@
from typing import Any, List, Tuple
-from pystencils import Assignment
+from pystencils.astnodes import SympyAssignment
from pystencils.boundaries.boundaryhandling import BoundaryOffsetInfo
from pystencils.typing import create_type
@@ -14,7 +14,7 @@ class Boundary:
def __init__(self, name=None):
self._name = name
- def __call__(self, field, direction_symbol, index_field) -> List[Assignment]:
+ def __call__(self, field, direction_symbol, index_field) -> List[SympyAssignment]:
"""Defines the boundary behavior and must therefore be implemented by all boundaries.
Here the boundary is defined as a list of sympy assignments, from which a boundary kernel is generated.
@@ -63,13 +63,13 @@ class Neumann(Boundary):
neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, field.spatial_dimensions)
if field.index_dimensions == 0:
- return [Assignment(field.center, field[neighbor])]
+ return [SympyAssignment(field.center, field[neighbor])]
else:
from itertools import product
if not field.has_fixed_index_shape:
raise NotImplementedError("Neumann boundary works only for fields with fixed index shape")
index_iter = product(*(range(i) for i in field.index_shape))
- return [Assignment(field(*idx), field[neighbor](*idx)) for idx in index_iter]
+ return [SympyAssignment(field(*idx), field[neighbor](*idx)) for idx in index_iter]
def __hash__(self):
# All boundaries of these class behave equal -> should also be equal
@@ -103,11 +103,11 @@ class Dirichlet(Boundary):
def __call__(self, field, direction_symbol, index_field, **kwargs):
if field.index_dimensions == 0:
- return [Assignment(field.center, index_field("value") if self.additional_data else self._value)]
+ return [SympyAssignment(field.center, index_field("value") if self.additional_data else self._value)]
elif field.index_dimensions == 1:
assert not self.additional_data
if not field.has_fixed_index_shape:
raise NotImplementedError("Field needs fixed index shape")
assert len(self._value) == field.index_shape[0], "Dirichlet value does not match index shape of field"
- return [Assignment(field(i), self._value[i]) for i in range(field.index_shape[0])]
+ return [SympyAssignment(field(i), self._value[i]) for i in range(field.index_shape[0])]
raise NotImplementedError("Dirichlet boundary not implemented for fields with more than one index dimension")
diff --git a/pystencils/boundaries/boundaryhandling.py b/pystencils/boundaries/boundaryhandling.py
index 52a314d75e5783085d73772439d91d0c44fb4d02..dcdd9e09e520c71fdfcc34d59e8de7c7d2edb4c0 100644
--- a/pystencils/boundaries/boundaryhandling.py
+++ b/pystencils/boundaries/boundaryhandling.py
@@ -2,7 +2,7 @@ import numpy as np
import sympy as sp
from pystencils import create_kernel, CreateKernelConfig, Target
-from pystencils.assignment import Assignment
+from pystencils.astnodes import SympyAssignment
from pystencils.backends.cbackend import CustomCodeNode
from pystencils.boundaries.createindexlist import (
create_boundary_index_array, numpy_data_type_for_boundary_object)
@@ -445,7 +445,7 @@ class BoundaryOffsetInfo(CustomCodeNode):
def create_boundary_kernel(field, index_field, stencil, boundary_functor, target=Target.CPU, **kernel_creation_args):
elements = [BoundaryOffsetInfo(stencil)]
dir_symbol = TypedSymbol("dir", np.int64)
- elements += [Assignment(dir_symbol, index_field[0]('dir'))]
+ elements += [SympyAssignment(dir_symbol, index_field[0]('dir'))]
elements += boundary_functor(field, direction_symbol=dir_symbol, index_field=index_field)
config = CreateKernelConfig(index_fields=[index_field], target=target, **kernel_creation_args)
return create_kernel(elements, config=config)
diff --git a/pystencils/cpu/kernelcreation.py b/pystencils/cpu/kernelcreation.py
index a937d3cf274290b7fe345c841878ccd2a396f9a8..7e4216568c169cf0be1eb46a52c25df765952da6 100644
--- a/pystencils/cpu/kernelcreation.py
+++ b/pystencils/cpu/kernelcreation.py
@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import Union
import sympy as sp
import numpy as np
@@ -96,8 +96,8 @@ def create_kernel(assignments: Union[AssignmentCollection, NodeCollection],
return ast_node
-def create_indexed_kernel(assignments: AssignmentCollection, index_fields, function_name="kernel",
- type_info=None, coordinate_names=('x', 'y', 'z')) -> KernelFunction:
+def create_indexed_kernel(assignments: Union[AssignmentCollection, NodeCollection],
+ config: CreateKernelConfig) -> KernelFunction:
"""
Similar to :func:`create_kernel`, but here not all cells of a field are updated but only cells with
coordinates which are stored in an index field. This traversal method can e.g. be used for boundary handling.
@@ -109,12 +109,17 @@ def create_indexed_kernel(assignments: AssignmentCollection, index_fields, funct
Args:
assignments: list of assignments
- index_fields: list of index fields, i.e. 1D fields with struct data type
- type_info: see documentation of :func:`create_kernel`
- function_name: see documentation of :func:`create_kernel`
- coordinate_names: name of the coordinate fields in the struct data type
+ config: Kernel configuration
"""
- fields_read, fields_written, assignments = add_types(assignments, type_info, check_independence_condition=False)
+ function_name = config.function_name
+ index_fields = config.index_fields
+ coordinate_names = config.coordinate_names
+ fields_written = assignments.bound_fields
+ fields_read = assignments.rhs_fields
+
+ assignments = assignments.all_assignments
+ assignments = add_types(assignments, config)
+
all_fields = fields_read.union(fields_written)
for index_field in index_fields:
diff --git a/pystencils/datahandling/parallel_datahandling.py b/pystencils/datahandling/parallel_datahandling.py
index 1fb8fe0bea37c60e764068f038fb37586b094278..9d1e898d7368c22faf6c1699a619587cb1c613a1 100644
--- a/pystencils/datahandling/parallel_datahandling.py
+++ b/pystencils/datahandling/parallel_datahandling.py
@@ -9,7 +9,7 @@ from pystencils.datahandling.blockiteration import block_iteration, sliced_block
from pystencils.datahandling.datahandling_interface import DataHandling
from pystencils.enums import Backend
from pystencils.field import Field, FieldType
-from pystencils.kernelparameters import FieldPointerSymbol
+from pystencils.typing.typed_sympy import FieldPointerSymbol
from pystencils.utils import DotDict
from pystencils import Target
diff --git a/pystencils/gpucuda/kernelcreation.py b/pystencils/gpucuda/kernelcreation.py
index f6daa669769f3fe936808fb8c089932d54ad4229..21721bb7f635e6424dd02bc17a7b41cc93fa02bf 100644
--- a/pystencils/gpucuda/kernelcreation.py
+++ b/pystencils/gpucuda/kernelcreation.py
@@ -1,26 +1,36 @@
+from typing import Union
+
import numpy as np
from pystencils.astnodes import Block, KernelFunction, LoopOverCoordinate, SympyAssignment
+from pystencils.config import CreateKernelConfig
from pystencils.typing import StructType, TypedSymbol
from pystencils.typing.transformations import add_types
from pystencils.field import Field, FieldType
from pystencils.enums import Target, Backend
from pystencils.gpucuda.cudajit import make_python_function
-from pystencils.gpucuda.indexing import BlockIndexing
+from pystencils.node_collection import NodeCollection
+from pystencils.gpucuda.indexing import BlockIndexing, indexing_creator_from_params
+from pystencils.simp.assignment_collection import AssignmentCollection
from pystencils.transformations import (
get_base_buffer_index, get_common_shape, parse_base_pointer_info,
resolve_buffer_accesses, resolve_field_accesses, unify_shape_symbols)
-def create_cuda_kernel(assignments,
- function_name="kernel",
- type_info=None,
- indexing_creator=BlockIndexing,
- iteration_slice=None,
- ghost_layers=None,
- skip_independence_check=False):
- assert assignments, "Assignments must not be empty!"
- fields_read, fields_written, assignments = add_types(assignments, type_info, not skip_independence_check)
+def create_cuda_kernel(assignments: Union[AssignmentCollection, NodeCollection],
+ config: CreateKernelConfig):
+
+ function_name = config.function_name
+ indexing_creator = indexing_creator_from_params(config.gpu_indexing, config.gpu_indexing_params)
+ iteration_slice = config.iteration_slice
+ ghost_layers = config.ghost_layers
+
+ fields_written = assignments.bound_fields
+ fields_read = assignments.rhs_fields
+ assignments = assignments.all_assignments
+
+ assignments = add_types(assignments, config)
+
all_fields = fields_read.union(fields_written)
read_only_fields = set([f.name for f in fields_read - fields_written])
@@ -103,13 +113,20 @@ def create_cuda_kernel(assignments,
return ast
-def created_indexed_cuda_kernel(assignments,
- index_fields,
- function_name="kernel",
- type_info=None,
- coordinate_names=('x', 'y', 'z'),
- indexing_creator=BlockIndexing):
- fields_read, fields_written, assignments = add_types(assignments, type_info, check_independence_condition=False)
+def created_indexed_cuda_kernel(assignments: Union[AssignmentCollection, NodeCollection],
+ config: CreateKernelConfig):
+
+ index_fields = config.index_fields
+ function_name = config.function_name
+ coordinate_names = config.coordinate_names
+ indexing_creator = indexing_creator_from_params(config.gpu_indexing, config.gpu_indexing_params)
+
+ fields_written = assignments.bound_fields
+ fields_read = assignments.rhs_fields
+ assignments = assignments.all_assignments
+
+ assignments = add_types(assignments, config)
+
all_fields = fields_read.union(fields_written)
read_only_fields = set([f.name for f in fields_read - fields_written])
diff --git a/pystencils/gpucuda/periodicity.py b/pystencils/gpucuda/periodicity.py
index 5a402c606fee50024c049efc3ad50ab40f417515..7cad51654de75c2462d7d846baccc916aa102d4d 100644
--- a/pystencils/gpucuda/periodicity.py
+++ b/pystencils/gpucuda/periodicity.py
@@ -1,9 +1,9 @@
import numpy as np
from itertools import product
+from pystencils import CreateKernelConfig, create_kernel
import pystencils.gpucuda
from pystencils import Assignment, Field
-from pystencils.gpucuda.kernelcreation import create_cuda_kernel
from pystencils.enums import Target
from pystencils.slicing import get_periodic_boundary_src_dst_slices, normalize_slice
@@ -26,13 +26,14 @@ def create_copy_kernel(domain_size, from_slice, to_slice, index_dimensions=0, in
eq = Assignment(f(*i), f[tuple(offset)](*i))
update_eqs.append(eq)
- ast = create_cuda_kernel(update_eqs, iteration_slice=to_slice, skip_independence_check=True)
+ config = CreateKernelConfig(target=Target.GPU, iteration_slice=to_slice, skip_independence_check=True)
+
+ ast = create_kernel(update_eqs, config=config)
return ast
-# TODO: type flot is dangerous here
def get_periodic_boundary_functor(stencil, domain_size, index_dimensions=0, index_dim_shape=1, ghost_layers=1,
- thickness=None, dtype=float, target=Target.GPU):
+ thickness=None, dtype=np.float64, target=Target.GPU):
assert target in {Target.GPU}
src_dst_slice_tuples = get_periodic_boundary_src_dst_slices(stencil, ghost_layers, thickness)
kernels = []
diff --git a/pystencils/kernel_decorator.py b/pystencils/kernel_decorator.py
index a8db7cb979008b76cde1ea64d4856df93436b43e..ad5d625929058ef383402e2a1d97c0dfadbf5fda 100644
--- a/pystencils/kernel_decorator.py
+++ b/pystencils/kernel_decorator.py
@@ -77,10 +77,10 @@ def kernel_config(config: CreateKernelConfig, **kwargs) -> Callable[..., Dict]:
and updates the function name accordingly.
Changes the meaning of the '@=' operator. Each line containing this operator gives a symbolic assignment
- in the result list. Furthermore the meaning of the ternary inline 'if-else' changes meaning to denote a
+ in the result list. Furthermore, the meaning of the ternary inline 'if-else' changes meaning to denote a
sympy Piecewise.
- The decorated function may not receive any arguments, with exception of an argument called 's' that specifies
+ The decorated function may not receive any arguments, with exception to an argument called 's' that specifies
a SymbolCreator()
Args:
config: Specify whether to return the list with assignments, or a dictionary containing additional settings
@@ -89,16 +89,15 @@ def kernel_config(config: CreateKernelConfig, **kwargs) -> Callable[..., Dict]:
decorator with config
Examples:
- >>> import pystencils.kernel_creation_config
>>> import pystencils as ps
- >>> config = pystencils.kernel_creation_config.CreateKernelConfig()
- >>> @kernel_config(config)
+ >>> kernel_configuration = ps.CreateKernelConfig()
+ >>> @kernel_config(kernel_configuration)
... def my_kernel(s):
- ... f, g = ps.fields('f, g: [2D]')
- ... s.neighbors @= f[0,1] + f[1,0]
- ... g[0,0] @= s.neighbors + f[0,0] if f[0,0] > 0 else 0
- >>> f, g = ps.fields('f, g: [2D]')
- >>> assert my_kernel['assignments'][0].rhs == f[0,1] + f[1,0]
+ ... src, dst = ps.fields('src, dst: [2D]')
+ ... s.neighbors @= src[0, 1] + src[1, 0]
+ ... dst[0, 0] @= s.neighbors + src[0, 0] if src[0, 0] > 0 else 0
+ >>> f, g = ps.fields('src, dst: [2D]')
+ >>> assert my_kernel['assignments'][0].rhs == f[0, 1] + f[1, 0]
"""
def decorator(func: Callable[..., None]) -> Union[List[Assignment], Dict]:
"""
diff --git a/pystencils/kernelcreation.py b/pystencils/kernelcreation.py
index 9c2198a815a1f2287b4b8559ab6a6866a70d2428..c63946bf0b05dd321a5c1da1672369932c80fe1e 100644
--- a/pystencils/kernelcreation.py
+++ b/pystencils/kernelcreation.py
@@ -11,7 +11,6 @@ from pystencils.cpu.vectorization import vectorize
from pystencils.enums import Target, Backend
from pystencils.field import Field, FieldType
from pystencils.node_collection import NodeCollection
-from pystencils.gpucuda.indexing import indexing_creator_from_params
from pystencils.simp.assignment_collection import AssignmentCollection
from pystencils.kernel_contrains_check import KernelConstraintsCheck
from pystencils.simplificationfactory import create_simplification_strategy
@@ -157,11 +156,7 @@ def create_domain_kernel(assignments: NodeCollection, *, config: CreateKernelCon
elif config.target == Target.GPU:
if config.backend == Backend.CUDA:
from pystencils.gpucuda import create_cuda_kernel
- ast = create_cuda_kernel(assignments, function_name=config.function_name, type_info=config.data_type,
- indexing_creator=indexing_creator_from_params(config.gpu_indexing,
- config.gpu_indexing_params),
- iteration_slice=config.iteration_slice, ghost_layers=config.ghost_layers,
- skip_independence_check=config.skip_independence_check)
+ ast = create_cuda_kernel(assignments, config=config)
if not ast:
raise NotImplementedError(
@@ -174,7 +169,7 @@ def create_domain_kernel(assignments: NodeCollection, *, config: CreateKernelCon
return ast
-def create_indexed_kernel(assignments: AssignmentCollection, *, config: CreateKernelConfig):
+def create_indexed_kernel(assignments: NodeCollection, *, config: CreateKernelConfig):
"""
Similar to :func:`create_kernel`, but here not all cells of a field are updated but only cells with
coordinates which are stored in an index field. This traversal method can e.g. be used for boundary handling.
@@ -218,24 +213,28 @@ def create_indexed_kernel(assignments: AssignmentCollection, *, config: CreateKe
[0., 0., 0., 4.3, 0.],
[0., 0., 0., 0., 0.]])
"""
- # TODO do this in backends
- assignments = assignments.all_assignments
+ # --- eval
+ assignments.evaluate_terms()
+
+ # FUTURE WORK from here we shouldn't NEED sympy
+ # --- check constrains
+ check = KernelConstraintsCheck(check_independence_condition=not config.skip_independence_check,
+ check_double_write_condition=not config.allow_double_writes)
+ check.visit(assignments)
+
+ assignments.bound_fields = check.fields_written
+ assignments.rhs_fields = check.fields_read
+
ast = None
if config.target == Target.CPU and config.backend == Backend.C:
from pystencils.cpu import add_openmp, create_indexed_kernel
- ast = create_indexed_kernel(assignments, index_fields=config.index_fields, type_info=config.data_type,
- coordinate_names=config.coordinate_names)
+ ast = create_indexed_kernel(assignments, config=config)
if config.cpu_openmp:
add_openmp(ast, num_threads=config.cpu_openmp)
elif config.target == Target.GPU:
if config.backend == Backend.CUDA:
from pystencils.gpucuda import created_indexed_cuda_kernel
- idx_creator = indexing_creator_from_params(config.gpu_indexing, config.gpu_indexing_params)
- ast = created_indexed_cuda_kernel(assignments,
- config.index_fields,
- type_info=config.data_type,
- coordinate_names=config.coordinate_names,
- indexing_creator=idx_creator)
+ ast = created_indexed_cuda_kernel(assignments, config=config)
if not ast:
raise NotImplementedError(f'Indexed kernels are not yet supported for {config.target} with {config.backend}')
@@ -358,11 +357,8 @@ def create_staggered_kernel(assignments, target: Target = Target.CPU, gpu_exclus
[SympyAssignment(s.lhs, s.rhs) for s in subexpressions if hasattr(s, 'lhs')] + \
[last_conditional]
- if target == Target.CPU:
- from pystencils.cpu import create_kernel as create_kernel_cpu
- ast = create_kernel_cpu(final_assignments, ghost_layers=ghost_layers, omp_single_loop=False, **kwargs)
- else:
- ast = create_kernel(final_assignments, ghost_layers=ghost_layers, target=target, **kwargs)
+ config = CreateKernelConfig(target=target, ghost_layers=ghost_layers, omp_single_loop=False, **kwargs)
+ ast = create_kernel(final_assignments, config=config)
return ast
for assignment in assignments:
@@ -379,6 +375,8 @@ def create_staggered_kernel(assignments, target: Target = Target.CPU, gpu_exclus
if 'cpu_prepend_optimizations' in kwargs:
prepend_optimizations += kwargs['cpu_prepend_optimizations']
del kwargs['cpu_prepend_optimizations']
- ast = create_kernel(final_assignments, ghost_layers=ghost_layers, target=target, omp_single_loop=False,
- cpu_prepend_optimizations=prepend_optimizations, **kwargs)
+
+ config = CreateKernelConfig(ghost_layers=ghost_layers, target=target, omp_single_loop=False,
+ cpu_prepend_optimizations=prepend_optimizations, **kwargs)
+ ast = create_kernel(final_assignments, config=config)
return ast
diff --git a/pystencils_tests/test_abs.py b/pystencils_tests/test_abs.py
index 2940295b00f8fb838e410227c8d8ceb7d74c7dc7..277cf4f5c4a39598aafbded82a267e6619c15bee 100644
--- a/pystencils_tests/test_abs.py
+++ b/pystencils_tests/test_abs.py
@@ -9,10 +9,6 @@ from pystencils.typing import CastFunc, create_type
@pytest.mark.parametrize('target', (ps.Target.CPU, ps.Target.GPU))
def test_abs(target):
- # TODO: GPU: Remove this !!!!!!!!
- if target == ps.Target.GPU:
- return True
-
x, y, z = ps.fields('x, y, z: float64[2d]')
default_int_type = create_type('int64')
diff --git a/pystencils_tests/test_buffer_gpu.py b/pystencils_tests/test_buffer_gpu.py
index 2b3f55df59a7b0b1218c41f7cf464e37bb36efbb..39750301a43288ada788f94cc469e055cb55f749 100644
--- a/pystencils_tests/test_buffer_gpu.py
+++ b/pystencils_tests/test_buffer_gpu.py
@@ -3,9 +3,9 @@
import numpy as np
import pytest
-from pystencils import Assignment, Field, FieldType
+import pystencils
+from pystencils import Assignment, Field, FieldType, CreateKernelConfig, create_kernel
from pystencils.field import create_numpy_array_with_layout, layout_string_to_tuple
-from pystencils.gpucuda import create_cuda_kernel, make_python_function
from pystencils.slicing import (
add_ghost_layers, get_ghost_region_slice, get_slice_before_ghost_layer)
from pystencils.stencil import direction_string_to_offset
@@ -57,16 +57,20 @@ def test_full_scalar_field():
pack_eqs = [Assignment(buffer.center(), src_field.center())]
pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- pack_code = create_cuda_kernel(pack_eqs, type_info=pack_types)
- pack_kernel = make_python_function(pack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+ 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}
- unpack_code = create_cuda_kernel(unpack_eqs, type_info=unpack_types)
- unpack_kernel = make_python_function(unpack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+ unpack_ast = create_kernel(unpack_eqs, config=config)
+
+ unpack_kernel = unpack_ast.compile()
unpack_kernel(dst_field=gpu_dst_arr, buffer=gpu_buffer_arr)
dst_arr = gpu_dst_arr.get()
@@ -91,17 +95,21 @@ def test_field_slice():
pack_eqs = [Assignment(buffer.center(), src_field.center())]
pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- pack_code = create_cuda_kernel(pack_eqs, type_info=pack_types)
- pack_kernel = make_python_function(pack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+ pack_ast = create_kernel(pack_eqs, config=config)
+
+ pack_kernel = pack_ast.compile()
pack_kernel(buffer=gpu_buffer_arr, src_field=gpu_src_arr[pack_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}
- unpack_code = create_cuda_kernel(unpack_eqs, type_info=unpack_types)
- unpack_kernel = make_python_function(unpack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+ unpack_ast = create_kernel(unpack_eqs, config=config)
+
+ unpack_kernel = unpack_ast.compile()
unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr[unpack_slice])
dst_arr = gpu_dst_arr.get()
@@ -127,8 +135,11 @@ def test_all_cell_values():
pack_eqs.append(eq)
pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- pack_code = create_cuda_kernel(pack_eqs, type_info=pack_types)
- pack_kernel = make_python_function(pack_code)
+
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+ pack_code = create_kernel(pack_eqs, config=config)
+ pack_kernel = pack_code.compile()
+
pack_kernel(buffer=gpu_buffer_arr, src_field=gpu_src_arr)
unpack_eqs = []
@@ -138,8 +149,10 @@ def test_all_cell_values():
unpack_eqs.append(eq)
unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- unpack_code = create_cuda_kernel(unpack_eqs, type_info=unpack_types)
- unpack_kernel = make_python_function(unpack_code)
+
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+ unpack_ast = create_kernel(unpack_eqs, config=config)
+ unpack_kernel = unpack_ast.compile()
unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr)
dst_arr = gpu_dst_arr.get()
@@ -167,8 +180,9 @@ def test_subset_cell_values():
pack_eqs.append(eq)
pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- pack_code = create_cuda_kernel(pack_eqs, type_info=pack_types)
- pack_kernel = make_python_function(pack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+ 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 = []
@@ -178,8 +192,10 @@ def test_subset_cell_values():
unpack_eqs.append(eq)
unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- unpack_code = create_cuda_kernel(unpack_eqs, type_info=unpack_types)
- unpack_kernel = make_python_function(unpack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+ unpack_ast = create_kernel(unpack_eqs, config=config)
+ unpack_kernel = unpack_ast.compile()
+
unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr)
dst_arr = gpu_dst_arr.get()
@@ -206,8 +222,10 @@ def test_field_layouts():
pack_eqs.append(eq)
pack_types = {'src_field': gpu_src_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- pack_code = create_cuda_kernel(pack_eqs, type_info=pack_types)
- pack_kernel = make_python_function(pack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=pack_types)
+ 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 = []
@@ -217,6 +235,8 @@ def test_field_layouts():
unpack_eqs.append(eq)
unpack_types = {'dst_field': gpu_dst_arr.dtype, 'buffer': gpu_buffer_arr.dtype}
- unpack_code = create_cuda_kernel(unpack_eqs, type_info=unpack_types)
- unpack_kernel = make_python_function(unpack_code)
+ config = CreateKernelConfig(target=pystencils.Target.GPU, data_type=unpack_types)
+ unpack_ast = create_kernel(unpack_eqs, config=config)
+ unpack_kernel = unpack_ast.compile()
+
unpack_kernel(buffer=gpu_buffer_arr, dst_field=gpu_dst_arr)
diff --git a/pystencils_tests/test_cuda_known_functions.py b/pystencils_tests/test_cuda_known_functions.py
index 7828c99f884450fd884084d6a2383729a30fcc66..b9e17ebdde786cf54a0d21177f870151eaf5c15f 100644
--- a/pystencils_tests/test_cuda_known_functions.py
+++ b/pystencils_tests/test_cuda_known_functions.py
@@ -5,7 +5,7 @@ import pytest
import pystencils
from pystencils.astnodes import get_dummy_symbol
from pystencils.backends.cuda_backend import CudaSympyPrinter
-from pystencils.functions import address_of
+from pystencils.functions import AddressOf
from pystencils.enums import Target
@@ -16,7 +16,7 @@ def test_cuda_known_functions():
x, y = pystencils.fields('x,y: float32 [2d]')
assignments = pystencils.AssignmentCollection({
- get_dummy_symbol(): sympy.Function('atomicAdd')(address_of(y.center()), 2),
+ get_dummy_symbol(): sympy.Function('atomicAdd')(AddressOf(y.center()), 2),
y.center(): sympy.Function('rsqrtf')(x[0, 0])
})
@@ -31,7 +31,7 @@ def test_cuda_but_not_c():
x, y = pystencils.fields('x,y: float32 [2d]')
assignments = pystencils.AssignmentCollection({
- get_dummy_symbol(): sympy.Function('atomicAdd')(address_of(y.center()), 2),
+ get_dummy_symbol(): sympy.Function('atomicAdd')(AddressOf(y.center()), 2),
y.center(): sympy.Function('rsqrtf')(x[0, 0])
})
@@ -43,7 +43,7 @@ def test_cuda_unknown():
x, y = pystencils.fields('x,y: float32 [2d]')
assignments = pystencils.AssignmentCollection({
- get_dummy_symbol(): sympy.Function('wtf')(address_of(y.center()), 2),
+ get_dummy_symbol(): sympy.Function('wtf')(AddressOf(y.center()), 2),
})
ast = pystencils.create_kernel(assignments, target=Target.GPU)
diff --git a/pystencils_tests/test_cudagpu.py b/pystencils_tests/test_cudagpu.py
index 520d859bf5cd94195a7622702bfed83432959afd..a65a08ba6d24b30002822e9916b2d3d44639d26a 100644
--- a/pystencils_tests/test_cudagpu.py
+++ b/pystencils_tests/test_cudagpu.py
@@ -4,9 +4,8 @@ import pycuda.gpuarray as gpuarray
import sympy as sp
from scipy.ndimage import convolve
-from pystencils import Assignment, Field, fields
-from pystencils.gpucuda import BlockIndexing, create_cuda_kernel, make_python_function
-from pystencils.gpucuda.indexing import LineIndexing
+from pystencils import Assignment, Field, fields, CreateKernelConfig, create_kernel, Target
+from pystencils.gpucuda import BlockIndexing
from pystencils.simp import sympy_cse_on_assignment_list
from pystencils.slicing import add_ghost_layers, make_slice, remove_ghost_layers
@@ -22,8 +21,9 @@ def test_averaging_kernel():
update_rule = Assignment(dst_field[0, 0],
(src_field[0, 1] + src_field[0, -1] + src_field[1, 0] + src_field[-1, 0]) / 4)
- ast = create_cuda_kernel(sympy_cse_on_assignment_list([update_rule]))
- kernel = make_python_function(ast)
+ config = CreateKernelConfig(target=Target.GPU)
+ ast = create_kernel(sympy_cse_on_assignment_list([update_rule]), config=config)
+ kernel = ast.compile()
gpu_src_arr = gpuarray.to_gpu(src_arr)
gpu_dst_arr = gpuarray.to_gpu(dst_arr)
@@ -43,8 +43,9 @@ def test_variable_sized_fields():
update_rule = Assignment(dst_field[0, 0],
(src_field[0, 1] + src_field[0, -1] + src_field[1, 0] + src_field[-1, 0]) / 4)
- ast = create_cuda_kernel(sympy_cse_on_assignment_list([update_rule]))
- kernel = make_python_function(ast)
+ config = CreateKernelConfig(target=Target.GPU)
+ ast = create_kernel(sympy_cse_on_assignment_list([update_rule]), config=config)
+ kernel = ast.compile()
size = (3, 3)
src_arr = np.random.rand(*size)
@@ -76,8 +77,9 @@ def test_multiple_index_dimensions():
update_rule = Assignment(dst_field[0, 0],
sum([src_field[offset[0], offset[1]](i) for i in range(src_size[-1])]))
- ast = create_cuda_kernel([update_rule])
- kernel = make_python_function(ast)
+ config = CreateKernelConfig(target=Target.GPU)
+ ast = create_kernel([update_rule], config=config)
+ kernel = ast.compile()
gpu_src_arr = gpuarray.to_gpu(src_arr)
gpu_dst_arr = gpuarray.to_gpu(dst_arr)
@@ -102,8 +104,10 @@ def test_ghost_layer():
update_rule = Assignment(dst_field[0, 0], src_field[0, 0])
ghost_layers = [(1, 2), (2, 1)]
- ast = create_cuda_kernel([update_rule], ghost_layers=ghost_layers, indexing_creator=LineIndexing)
- kernel = make_python_function(ast)
+
+ config = CreateKernelConfig(target=Target.GPU, ghost_layers=ghost_layers, gpu_indexing="line")
+ ast = create_kernel(sympy_cse_on_assignment_list([update_rule]), config=config)
+ kernel = ast.compile()
gpu_src_arr = gpuarray.to_gpu(src_arr)
gpu_dst_arr = gpuarray.to_gpu(dst_arr)
@@ -122,9 +126,11 @@ def test_setting_value():
iteration_slice = make_slice[:, :]
f = Field.create_generic("f", 2)
update_rule = [Assignment(f(0), sp.Symbol("value"))]
- ast = create_cuda_kernel(update_rule, iteration_slice=iteration_slice, indexing_creator=LineIndexing)
- kernel = make_python_function(ast)
+ config = CreateKernelConfig(target=Target.GPU, gpu_indexing="line", iteration_slice=iteration_slice)
+ ast = create_kernel(sympy_cse_on_assignment_list(update_rule), config=config)
+ kernel = ast.compile()
+
kernel(f=arr_gpu, value=np.float64(42.0))
np.testing.assert_equal(arr_gpu.get(), np.ones((5, 5)) * 42.0)
diff --git a/pystencils_tests/test_custom_backends.py b/pystencils_tests/test_custom_backends.py
index e5942fcbf7f102017f2d240f89f0f841b22a596c..3d0088796e6d6ea6683f69124731cd64fad09507 100644
--- a/pystencils_tests/test_custom_backends.py
+++ b/pystencils_tests/test_custom_backends.py
@@ -1,7 +1,6 @@
from subprocess import CalledProcessError
import pytest
-import sympy
import pystencils
import pystencils.cpu.cpujit
diff --git a/pystencils_tests/test_indexed_kernels.py b/pystencils_tests/test_indexed_kernels.py
index fd994c7f9326d0b175a1adf7042e43938e621ad3..87b24b354accb1f5936660378078d8a9f70a94fa 100644
--- a/pystencils_tests/test_indexed_kernels.py
+++ b/pystencils_tests/test_indexed_kernels.py
@@ -1,7 +1,5 @@
import numpy as np
-
-from pystencils import Assignment, Field
-from pystencils.cpu import create_indexed_kernel, make_python_function
+from pystencils import Assignment, Field, CreateKernelConfig, create_kernel, Target
def test_indexed_kernel():
@@ -15,8 +13,10 @@ def test_indexed_kernel():
indexed_field = Field.create_from_numpy_array('index', index_arr)
normal_field = Field.create_from_numpy_array('f', arr)
update_rule = Assignment(normal_field[0, 0], indexed_field('value'))
- ast = create_indexed_kernel([update_rule], [indexed_field])
- kernel = make_python_function(ast)
+
+ config = CreateKernelConfig(index_fields=[indexed_field])
+ ast = create_kernel([update_rule], config=config)
+ kernel = ast.compile()
kernel(f=arr, index=index_arr)
for i in range(index_arr.shape[0]):
np.testing.assert_allclose(arr[index_arr[i]['x'], index_arr[i]['y']], index_arr[i]['value'], atol=1e-13)
@@ -29,9 +29,7 @@ def test_indexed_cuda_kernel():
pycuda = None
if pycuda:
- from pystencils.gpucuda import make_python_function
import pycuda.gpuarray as gpuarray
- from pystencils.gpucuda.kernelcreation import created_indexed_cuda_kernel
arr = np.zeros((3, 4))
dtype = np.dtype([('x', int), ('y', int), ('value', arr.dtype)])
@@ -43,8 +41,10 @@ def test_indexed_cuda_kernel():
indexed_field = Field.create_from_numpy_array('index', index_arr)
normal_field = Field.create_from_numpy_array('f', arr)
update_rule = Assignment(normal_field[0, 0], indexed_field('value'))
- ast = created_indexed_cuda_kernel([update_rule], [indexed_field])
- kernel = make_python_function(ast)
+
+ config = CreateKernelConfig(target=Target.GPU, index_fields=[indexed_field])
+ ast = create_kernel([update_rule], config=config)
+ kernel = ast.compile()
gpu_arr = gpuarray.to_gpu(arr)
gpu_index_arr = gpuarray.to_gpu(index_arr)
diff --git a/pystencils_tests/test_types.py b/pystencils_tests/test_types.py
index 164d941cf6e9d1d4fbed300c901c73709c82005e..8ac96f84e732debd8e1ff50426c483b6b5523868 100644
--- a/pystencils_tests/test_types.py
+++ b/pystencils_tests/test_types.py
@@ -5,7 +5,7 @@ import sympy as sp
import numpy as np
import pystencils as ps
-from pystencils.typing import TypedSymbol, get_type_of_expression, VectorType, collate_types, create_type, \
+from pystencils.typing import TypedSymbol, get_type_of_expression, VectorType, collate_types, \
typed_symbols, CastFunc, PointerArithmeticFunc, PointerType, result_type, BasicType