Skip to content
Snippets Groups Projects
Commit 36669cd8 authored by Markus Holzer's avatar Markus Holzer
Browse files

Fix remaining tests

parent 212380d6
No related branches found
No related tags found
1 merge request!391Thread safety
Expand all Hide whitespace changes
Inline Side-by-side
doc/notebooks/02_tutorial_basic_kernels.ipynb
+ 8
− 7
View file @ 36669cd8
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
from pystencils.session import * from pystencils.session import *
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
# Tutorial 02: Basic Kernel generation with *pystencils* # Tutorial 02: Basic Kernel generation with *pystencils*
Now that you have an [overview of pystencils](01_tutorial_getting_started.ipynb), Now that you have an [overview of pystencils](01_tutorial_getting_started.ipynb),
this tutorial shows in more detail how to formulate, optimize and run stencil kernels. this tutorial shows in more detail how to formulate, optimize and run stencil kernels.
## 1) Kernel Definition ## 1) Kernel Definition
### a) Defining kernels with assignment lists and the `kernel` decorator ### a) Defining kernels with assignment lists and the `kernel` decorator
*pystencils* gets a symbolic formulation of the kernel. This can be either an `Assignment` or a sequence of `Assignment`s that follow a set of restrictions. *pystencils* gets a symbolic formulation of the kernel. This can be either an `Assignment` or a sequence of `Assignment`s that follow a set of restrictions.
Lets first create a kernel that consists of multiple assignments: Lets first create a kernel that consists of multiple assignments:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
src_arr = np.zeros([20, 30]) src_arr = np.zeros([20, 30])
dst_arr = np.zeros_like(src_arr) dst_arr = np.zeros_like(src_arr)
dst, src = ps.fields(dst=dst_arr, src=src_arr) dst, src = ps.fields(dst=dst_arr, src=src_arr)
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
grad_x, grad_y = sp.symbols("grad_x, grad_y") grad_x, grad_y = sp.symbols("grad_x, grad_y")
symbolic_description = [ symbolic_description = [
ps.Assignment(grad_x, (src[1, 0] - src[-1, 0]) / 2), ps.Assignment(grad_x, (src[1, 0] - src[-1, 0]) / 2),
ps.Assignment(grad_y, (src[0, 1] - src[0, -1]) / 2), ps.Assignment(grad_y, (src[0, 1] - src[0, -1]) / 2),
ps.Assignment(dst[0, 0], grad_x + grad_y), ps.Assignment(dst[0, 0], grad_x + grad_y),
] ]
kernel = ps.create_kernel(symbolic_description) kernel = ps.create_kernel(symbolic_description)
symbolic_description symbolic_description
``` ```
%% Output %% Output
$\displaystyle \left[ grad_{x} \leftarrow_{} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2}, \ grad_{y} \leftarrow_{} \frac{{src}_{(0,1)}}{2} - \frac{{src}_{(0,-1)}}{2}, \ {dst}_{(0,0)} \leftarrow_{} grad_{x} + grad_{y}\right]$ $\displaystyle \left[ grad_{x} \leftarrow_{} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2}, \ grad_{y} \leftarrow_{} \frac{{src}_{(0,1)}}{2} - \frac{{src}_{(0,-1)}}{2}, \ {dst}_{(0,0)} \leftarrow_{} grad_{x} + grad_{y}\right]$
⎡ src_E src_W src_N src_S ⎤ ⎡ src_E src_W src_N src_S ⎤
⎢gradₓ := ───── - ─────, grad_y := ───── - ─────, dst_C := gradₓ + grad_y⎥ ⎢gradₓ := ───── - ─────, grad_y := ───── - ─────, dst_C := gradₓ + grad_y⎥
⎣ 2 2 2 2 ⎦ ⎣ 2 2 2 2 ⎦
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
We created subexpressions, using standard sympy symbols on the left hand side, to split the kernel into multiple assignments. Defining a kernel using a list of `Assignment`s is quite tedious and hard to read. We created subexpressions, using standard sympy symbols on the left hand side, to split the kernel into multiple assignments. Defining a kernel using a list of `Assignment`s is quite tedious and hard to read.
To simplify the formulation of a kernel, *pystencils* offers the `kernel` decorator, that transforms a normal Python function with `@=` assignments into an assignment list that can be passed to `create_kernel`. To simplify the formulation of a kernel, *pystencils* offers the `kernel` decorator, that transforms a normal Python function with `@=` assignments into an assignment list that can be passed to `create_kernel`.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
@ps.kernel @ps.kernel
def symbolic_description_using_function(): def symbolic_description_using_function():
grad_x @= (src[1, 0] - src[-1, 0]) / 2 grad_x @= (src[1, 0] - src[-1, 0]) / 2
grad_y @= (src[0, 1] - src[0, -1]) / 2 grad_y @= (src[0, 1] - src[0, -1]) / 2
dst[0, 0] @= grad_x + grad_y dst[0, 0] @= grad_x + grad_y
symbolic_description_using_function symbolic_description_using_function
``` ```
%% Output %% Output
$\displaystyle \left[ grad_{x} \leftarrow_{} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2}, \ grad_{y} \leftarrow_{} \frac{{src}_{(0,1)}}{2} - \frac{{src}_{(0,-1)}}{2}, \ {dst}_{(0,0)} \leftarrow_{} grad_{x} + grad_{y}\right]$ $\displaystyle \left[ grad_{x} \leftarrow_{} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2}, \ grad_{y} \leftarrow_{} \frac{{src}_{(0,1)}}{2} - \frac{{src}_{(0,-1)}}{2}, \ {dst}_{(0,0)} \leftarrow_{} grad_{x} + grad_{y}\right]$
⎡ src_E src_W src_N src_S ⎤ ⎡ src_E src_W src_N src_S ⎤
⎢gradₓ := ───── - ─────, grad_y := ───── - ─────, dst_C := gradₓ + grad_y⎥ ⎢gradₓ := ───── - ─────, grad_y := ───── - ─────, dst_C := gradₓ + grad_y⎥
⎣ 2 2 2 2 ⎦ ⎣ 2 2 2 2 ⎦
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
The decorated function can contain any Python code, only the `@=` operator, and the ternary inline `if-else` operator have different meaning. The decorated function can contain any Python code, only the `@=` operator, and the ternary inline `if-else` operator have different meaning.
### b) Ternary 'if' with `Piecewise` ### b) Ternary 'if' with `Piecewise`
The ternary operator maps to `sympy.Piecewise` functions, that can be used to introduce branching into the kernel. Piecewise defined functions must give a value for every input, i.e. there must be a 'otherwise' clause in the end that is indicated by the condition `True`. Piecewise objects are standard sympy terms that can be integrated into bigger expressions: The ternary operator maps to `sympy.Piecewise` functions, that can be used to introduce branching into the kernel. Piecewise defined functions must give a value for every input, i.e. there must be a 'otherwise' clause in the end that is indicated by the condition `True`. Piecewise objects are standard sympy terms that can be integrated into bigger expressions:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
sp.Piecewise((1.0, src[0,1] > 0), (0.0, True)) + src[1, 0] sp.Piecewise((1.0, src[0,1] > 0), (0.0, True)) + src[1, 0]
``` ```
%% Output %% Output
$\displaystyle {src}_{(1,0)} + \begin{cases} 1.0 & \text{for}\: {src}_{(0,1)} > 0 \\0.0 & \text{otherwise} \end{cases}$ $\displaystyle {src}_{(1,0)} + \begin{cases} 1.0 & \text{for}\: {src}_{(0,1)} > 0 \\0.0 & \text{otherwise} \end{cases}$
⎛⎧1.0 for src_N > 0⎞ ⎛⎧1.0 for src_N > 0⎞
src_E + ⎜⎨ ⎟ src_E + ⎜⎨ ⎟
⎝⎩0.0 otherwise ⎠ ⎝⎩0.0 otherwise ⎠
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Piecewise objects are created by the `kernel` decorator for ternary if-else statements. Piecewise objects are created by the `kernel` decorator for ternary if-else statements.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
@ps.kernel @ps.kernel
def kernel_with_piecewise(): def kernel_with_piecewise():
grad_x @= (src[1, 0] - src[-1, 0]) / 2 if src[-1, 0] > 0 else 0.0 grad_x @= (src[1, 0] - src[-1, 0]) / 2 if src[-1, 0] > 0 else 0.0
kernel_with_piecewise kernel_with_piecewise
``` ```
%% Output %% Output
$\displaystyle \left[ grad_{x} \leftarrow_{} \begin{cases} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2} & \text{for}\: {src}_{(-1,0)} > 0 \\0.0 & \text{otherwise} \end{cases}\right]$ $\displaystyle \left[ grad_{x} \leftarrow_{} \begin{cases} \frac{{src}_{(1,0)}}{2} - \frac{{src}_{(-1,0)}}{2} & \text{for}\: {src}_{(-1,0)} > 0 \\0.0 & \text{otherwise} \end{cases}\right]$
⎡ ⎧src_E src_W ⎤ ⎡ ⎧src_E src_W ⎤
⎢ ⎪───── - ───── for src_W > 0⎥ ⎢ ⎪───── - ───── for src_W > 0⎥
⎢gradₓ := ⎨ 2 2 ⎥ ⎢gradₓ := ⎨ 2 2 ⎥
⎢ ⎪ ⎥ ⎢ ⎪ ⎥
⎣ ⎩ 0.0 otherwise ⎦ ⎣ ⎩ 0.0 otherwise ⎦
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### c) Assignment level optimizations using `AssignmentCollection` ### c) Assignment level optimizations using `AssignmentCollection`
When the kernels get larger and more complex, it is helpful to organize the list of assignment into a more structured way. The `AssignmentCollection` offers optimizating transformation on a list of assignments. It holds two assignment lists, one for subexpressions and one for the main assignments. Main assignments are typically those that write to an array. When the kernels get larger and more complex, it is helpful to organize the list of assignment into a more structured way. The `AssignmentCollection` offers optimizating transformation on a list of assignments. It holds two assignment lists, one for subexpressions and one for the main assignments. Main assignments are typically those that write to an array.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
@ps.kernel @ps.kernel
def somewhat_longer_dummy_kernel(s): def somewhat_longer_dummy_kernel(s):
s.a @= src[0, 1] + src[-1, 0] s.a @= src[0, 1] + src[-1, 0]
s.b @= 2 * src[1, 0] + src[0, -1] s.b @= 2 * src[1, 0] + src[0, -1]
s.c @= src[0, 1] + 2 * src[1, 0] + src[-1, 0] + src[0, -1] - src[0,0] s.c @= src[0, 1] + 2 * src[1, 0] + src[-1, 0] + src[0, -1] - src[0,0]
dst[0, 0] @= s.a + s.b + s.c dst[0, 0] @= s.a + s.b + s.c
ac = ps.AssignmentCollection(main_assignments=somewhat_longer_dummy_kernel[-1:], ac = ps.AssignmentCollection(main_assignments=somewhat_longer_dummy_kernel[-1:],
subexpressions=somewhat_longer_dummy_kernel[:-1]) subexpressions=somewhat_longer_dummy_kernel[:-1])
ac ac
``` ```
%% Output %% Output
AssignmentCollection: dst_C, <- f(src_W, src_C, src_S, src_E, src_N) AssignmentCollection: dst_C, <- f(src_C, src_W, src_S, src_N, src_E)
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
ac.operation_count ac.operation_count
``` ```
%% Output %% Output
{'adds': 8, {'adds': 8,
'muls': 2, 'muls': 2,
'divs': 0, 'divs': 0,
'sqrts': 0, 'sqrts': 0,
'fast_sqrts': 0, 'fast_sqrts': 0,
'fast_inv_sqrts': 0, 'fast_inv_sqrts': 0,
'fast_div': 0} 'fast_div': 0}
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
The `pystencils.simp` submodule offers several functions to optimize a collection of assignments. The `pystencils.simp` submodule offers several functions to optimize a collection of assignments.
It also offers functionality to group optimization into strategies and evaluate them. It also offers functionality to group optimization into strategies and evaluate them.
In this example we reduce the number of operations by reusing existing subexpressions to get rid of two unnecessary floating point additions. For more information about assignment collections and simplifications see the [demo notebook](demo_assignment_collection.ipynb). In this example we reduce the number of operations by reusing existing subexpressions to get rid of two unnecessary floating point additions. For more information about assignment collections and simplifications see the [demo notebook](demo_assignment_collection.ipynb).
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
opt_ac = ps.simp.subexpression_substitution_in_existing_subexpressions(ac) opt_ac = ps.simp.subexpression_substitution_in_existing_subexpressions(ac)
opt_ac opt_ac
``` ```
%% Output %% Output
AssignmentCollection: dst_C, <- f(src_W, src_C, src_S, src_E, src_N) AssignmentCollection: dst_C, <- f(src_C, src_W, src_S, src_N, src_E)
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
opt_ac.operation_count opt_ac.operation_count
``` ```
%% Output %% Output
{'adds': 6, {'adds': 6,
'muls': 1, 'muls': 1,
'divs': 0, 'divs': 0,
'sqrts': 0, 'sqrts': 0,
'fast_sqrts': 0, 'fast_sqrts': 0,
'fast_inv_sqrts': 0, 'fast_inv_sqrts': 0,
'fast_div': 0} 'fast_div': 0}
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### d) Ghost layers and iteration region ### d) Ghost layers and iteration region
When creating a kernel with neighbor accesses, *pystencils* automatically restricts the iteration region, such that all accesses are safe. When creating a kernel with neighbor accesses, *pystencils* automatically restricts the iteration region, such that all accesses are safe.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
kernel = ps.create_kernel(ps.Assignment(dst[0,0], src[2, 0] + src[-1, 0])) kernel = ps.create_kernel(ps.Assignment(dst[0,0], src[2, 0] + src[-1, 0]))
ps.show_code(kernel) ps.show_code(kernel)
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
When no additional ghost layer information is given, *pystencils* looks at all neighboring field accesses and introduces the required number of ghost layers **for all directions**. In the example above the largest neighbor accesses was ``src[2, 0]``, so theoretically we would need 2 ghost layers only the the end of the x coordinate. When no additional ghost layer information is given, *pystencils* looks at all neighboring field accesses and introduces the required number of ghost layers **for all directions**. In the example above the largest neighbor accesses was ``src[2, 0]``, so theoretically we would need 2 ghost layers only the the end of the x coordinate.
By default *pystencils* introduces 2 ghost layers at all borders of the domain. The next cell shows how to change this behavior. Be careful with manual ghost layer specification, wrong values may lead to SEGFAULTs. By default *pystencils* introduces 2 ghost layers at all borders of the domain. The next cell shows how to change this behavior. Be careful with manual ghost layer specification, wrong values may lead to SEGFAULTs.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
gl_spec = [(0, 2), # 0 ghost layers at the left, 2 at the right border gl_spec = [(0, 2), # 0 ghost layers at the left, 2 at the right border
(1, 0)] # 1 ghost layer at the lower y, one at the upper y coordinate (1, 0)] # 1 ghost layer at the lower y, one at the upper y coordinate
kernel = ps.create_kernel(ps.Assignment(dst[0,0], src[2, 0] + src[-1, 0]), ghost_layers=gl_spec) kernel = ps.create_kernel(ps.Assignment(dst[0,0], src[2, 0] + src[-1, 0]), ghost_layers=gl_spec)
ps.show_code(kernel) ps.show_code(kernel)
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
## 2 ) Restrictions ## 2 ) Restrictions
### a) Independence Restriction ### a) Independence Restriction
*pystencils* only works for kernels where each array element can be updated independently from all other elements. This restriction ensures that the kernels can be easily parallelized and also be run on the GPU. Trying to define kernels where the results depends on the iteration order, leads to a ValueError. *pystencils* only works for kernels where each array element can be updated independently from all other elements. This restriction ensures that the kernels can be easily parallelized and also be run on the GPU. Trying to define kernels where the results depends on the iteration order, leads to a ValueError.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
invalid_description = [ invalid_description = [
ps.Assignment(dst[1, 0], src[1, 0] + src[-1, 0]), ps.Assignment(dst[1, 0], src[1, 0] + src[-1, 0]),
ps.Assignment(dst[0, 0], src[1, 0] - src[-1, 0]), ps.Assignment(dst[0, 0], src[1, 0] - src[-1, 0]),
] ]
try: try:
invalid_kernel = ps.create_kernel(invalid_description) invalid_kernel = ps.create_kernel(invalid_description)
assert False, "Should never be executed" assert False, "Should never be executed"
except ValueError as e: except ValueError as e:
print(e) print(e)
``` ```
%% Output %% Output
Field dst is written at two different locations Field dst is written at two different locations
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
The independence restriction makes sure that the kernel can be safely parallelized by checking the following conditions: If a field is modified inside the kernel, it may only be modified at a single spatial position. In that case the field may also only be read at this position. Fields that are not modified may be read at multiple neighboring positions. The independence restriction makes sure that the kernel can be safely parallelized by checking the following conditions: If a field is modified inside the kernel, it may only be modified at a single spatial position. In that case the field may also only be read at this position. Fields that are not modified may be read at multiple neighboring positions.
Specifically, this rule allows for in-place updates that don't access neighbors. Specifically, this rule allows for in-place updates that don't access neighbors.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
valid_kernel = ps.create_kernel(ps.Assignment(src[0,0], 2*src[0,0] + 42)) valid_kernel = ps.create_kernel(ps.Assignment(src[0,0], 2*src[0,0] + 42))
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
If a field stores multiple values per cell, as in the next example, this restriction only applies for accesses with the same index. If a field stores multiple values per cell, as in the next example, this restriction only applies for accesses with the same index.
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
v = ps.fields("v(2): double[2D]") v = ps.fields("v(2): double[2D]")
valid_kernel = ps.create_kernel([ps.Assignment(v[0,0](1), 2*v[0,0](1) + 42), valid_kernel = ps.create_kernel([ps.Assignment(v[0,0](1), 2*v[0,0](1) + 42),
ps.Assignment(v[0,1](0), 2*v[1,0](0) + 42)]) ps.Assignment(v[0,1](0), 2*v[0,1](0) + 42)])
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
### b) Static Single Assignment Form ### b) Static Single Assignment Form
All assignments that don't write to a field must be in SSA form All assignments that don't write to a field must be in SSA form
1. Each sympy symbol may only occur once as a left-hand-side (fields can be written multiple times) 1. Each sympy symbol may only occur once as a left-hand-side (fields can be written multiple times)
2. A symbol has to be defined before it is used. If it is never defined it is introduced as function parameter 2. A symbol has to be defined before it is used. If it is never defined it is introduced as function parameter
The next cell demonstrates the first SSA restriction: The next cell demonstrates the first SSA restriction:
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
@ps.kernel @ps.kernel
def not_allowed(): def not_allowed():
a, b = sp.symbols("a b") a, b = sp.symbols("a b")
a @= src[0, 0] a @= src[0, 0]
b @= a + 3 b @= a + 3
a @= src[-1, 0] a @= src[-1, 0]
dst[0, 0] @= a + b dst[0, 0] @= a + b
try: try:
ps.create_kernel(not_allowed) ps.create_kernel(not_allowed)
assert False assert False
except ValueError as e: except ValueError as e:
print(e) print(e)
``` ```
%% Output %% Output
Assignments not in SSA form, multiple assignments to a Assignments not in SSA form, multiple assignments to a
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
Also it is not allowed to write a field at the same location Also it is not allowed to write a field at the same location
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
@ps.kernel @ps.kernel
def not_allowed(): def not_allowed():
dst[0, 0] @= src[0, 1] + src[1, 0] dst[0, 0] @= src[0, 1] + src[1, 0]
dst[0, 0] @= 2 * dst[0, 0] dst[0, 0] @= 2 * dst[0, 0]
try: try:
ps.create_kernel(not_allowed) ps.create_kernel(not_allowed)
assert False assert False
except ValueError as e: except ValueError as e:
print(e) print(e)
``` ```
%% Output %% Output
Field dst is written twice at the same location Field dst is written twice at the same location
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
This situation should be resolved by introducing temporary variables This situation should be resolved by introducing temporary variables
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
tmp_var = sp.Symbol("a") tmp_var = sp.Symbol("a")
@ps.kernel @ps.kernel
def allowed(): def allowed():
tmp_var @= src[0, 1] + src[1, 0] tmp_var @= src[0, 1] + src[1, 0]
dst[0, 0] @= 2 * tmp_var dst[0, 0] @= 2 * tmp_var
ast = ps.create_kernel(allowed) ast = ps.create_kernel(allowed)
ps.show_code(ast) ps.show_code(ast)
``` ```
%% Output %% Output
......
doc/notebooks/demo_assignment_collection.ipynb
+ 47
− 39
View file @ 36669cd8
This diff is collapsed.
tests/test_jupyter_extensions.ipynb
+ 44
− 20
View file @ 36669cd8
This diff is collapsed.
tests/test_phasefield_dentritic_3D.ipynb
+ 1
− 1
View file @ 36669cd8
...@@ -370,7 +370,7 @@ ...@@ -370,7 +370,7 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.11.6" "version": "3.11.4"
} }
}, },
"nbformat": 4, "nbformat": 4,
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment