Remove LLVM

CHANGELOG.md

+# Change Log
+
+## Unreleased
+
+### Removed
+* LLVM backend because it was not used much and not good integrated in pystencils.

MANIFEST.in

@@ -2,6 +2,7 @@ include README.md
 include COPYING.txt
 include AUTHORS.txt
 include CONTRIBUTING.md
+CHANGELOG.md
 global-include *.pyx
 include versioneer.py
 include pystencils/_version.py

README.md

@@ -60,7 +60,6 @@ All options:
 - `autodiff`: enable derivation of adjoint kernels and generation of Torch/Tensorflow operations
 - `doc`: packages to build documentation
 - `kerncraft`: use kerncraft for automatic performance analysis
-- `llvm_jit`: llvmlite as additional CPU backend
 
 Options can be combined e.g.
 ```bash
@@ -73,12 +72,12 @@ Documentation
 -------------
 
 Read the docs [here](https://pycodegen.pages.i10git.cs.fau.de/pystencils) and
-check out the Jupyter notebooks in `doc/notebooks`.
+check out the Jupyter notebooks in `doc/notebooks`. The **Changelog** of pystencils can be found [here](https://i10git.cs.fau.de/pycodegen/pystencils/-/blob/master/CHANGELOG.md).
 
 Authors
 -------
 
-Many thanks go to the [contributors](AUTHORS.txt) of pystencils.
+Many thanks go to the [contributors](https://i10git.cs.fau.de/pycodegen/pystencils/-/blob/master/AUTHORS.txt) of pystencils.
 
 ### Please cite us
 

pystencils/backends/__init__.py

@@ -6,9 +6,3 @@ try:
     __all__.append('print_dot')
 except ImportError:
     pass
-
-try:
-    from .llvm import generate_llvm  # NOQA
-    __all__.append('generate_llvm')
-except ImportError:
-    pass

pystencils/cpu/cpujit.py

@@ -138,22 +138,11 @@ def create_folder(path, is_file):
         pass
 
 
-def get_llc_command():
-    """Try to get executable for llvm's IR compiler llc
-
-    We try if one of the following is in PATH: llc, llc-10, llc-9, llc-8, llc-7, llc-6
-    """
-    candidates = ['llc', 'llc-10', 'llc-9', 'llc-8', 'llc-7', 'llc-6']
-    found_executables = (e for e in candidates if shutil.which(e))
-    return next(found_executables, None)
-
-
 def read_config():
     if platform.system().lower() == 'linux':
         default_compiler_config = OrderedDict([
             ('os', 'linux'),
             ('command', 'g++'),
-            ('llc_command', get_llc_command() or 'llc'),
             ('flags', '-Ofast -DNDEBUG -fPIC -march=native -fopenmp -std=c++11'),
             ('restrict_qualifier', '__restrict__')
         ])
@@ -164,7 +153,6 @@ def read_config():
         default_compiler_config = OrderedDict([
             ('os', 'windows'),
             ('msvc_version', 'latest'),
-            ('llc_command', get_llc_command() or 'llc'),
             ('arch', 'x64'),
             ('flags', '/Ox /fp:fast /OpenMP /arch:avx'),
             ('restrict_qualifier', '__restrict')
@@ -173,7 +161,6 @@ def read_config():
         default_compiler_config = OrderedDict([
             ('os', 'darwin'),
             ('command', 'clang++'),
-            ('llc_command', get_llc_command() or 'llc'),
             ('flags', '-Ofast -DNDEBUG -fPIC -march=native -Xclang -fopenmp -std=c++11'),
             ('restrict_qualifier', '__restrict__')
         ])

pystencils/enums.py

@@ -28,11 +28,6 @@ class Backend(Enum):
     """
     Use the C Backend of pystencils.
     """
-    LLVM = auto()
-    r"""
-    Use the ``llvmlite`` package to transform the pystensilc AST to the LLVM ir. 
-    From this point all of LLVMs optimisations can be used.
-    """
     CUDA = auto()
     """
     Use the CUDA backend to generate code for NVIDIA GPUs.

pystencils/kernelcreation.py

@@ -278,11 +278,6 @@ def create_domain_kernel(assignments: List[Assignment], *, config: CreateKernelC
                         raise ValueError("Blocking cannot be combined with cacheline-zeroing")
                 else:
                     raise ValueError("Invalid value for cpu_vectorize_info")
-        elif config.backend == Backend.LLVM:
-            from pystencils.llvm import create_kernel
-            ast = create_kernel(assignments, function_name=config.function_name, type_info=config.data_type,
-                                split_groups=split_groups, iteration_slice=config.iteration_slice,
-                                ghost_layers=config.ghost_layers)
     elif config.target == Target.GPU or config.target == Target.OPENCL:
         if config.backend == Backend.CUDA or config.backend == Backend.OPENCL:
             from pystencils.gpucuda import create_cuda_kernel

pystencils/llvm/__init__.py

-from .kernelcreation import create_kernel
-from .llvmjit import make_python_function
-
-__all__ = ['create_kernel', 'make_python_function']

pystencils/llvm/control_flow.py

-import llvmlite.ir as ir
-
-
-class Loop(object):
-    def __init__(self, builder, start_val, stop_val, step_val=1, loop_name='loop', phi_name="_phi"):
-        self.builder = builder
-        self.start_val = start_val
-        self.stop_val = stop_val
-        self.step_val = step_val
-        self.loop_name = loop_name
-        self.phi_name = phi_name
-
-    def __enter__(self):
-        self.loop_end, self.after, phi = self._for_loop(self.start_val, self.stop_val, self.step_val, self.loop_name,
-                                                        self.phi_name)
-        return phi
-
-    def _for_loop(self, start_val, stop_val, step_val, loop_name, phi_name):
-        # TODO size of int??? unisgned???
-        integer = ir.IntType(64)
-
-        # Loop block
-        pre_loop_bb = self.builder.block
-        loop_bb = self.builder.append_basic_block(name='loop_' + loop_name)
-
-        self.builder.branch(loop_bb)
-
-        # Insert an explicit fall through from the current block to loop_bb
-        self.builder.position_at_start(loop_bb)
-
-        # Add phi
-        phi = self.builder.phi(integer, name=phi_name)
-        phi.add_incoming(start_val, pre_loop_bb)
-
-        loop_end_bb = self.builder.append_basic_block(name=loop_name + "_end_bb")
-        self.builder.position_at_start(loop_end_bb)
-
-        next_var = self.builder.add(phi, step_val, name=loop_name + '_next_it')
-        cond = self.builder.icmp_unsigned('<', next_var, stop_val, name=loop_name + "_cond")
-
-        after_bb = self.builder.append_basic_block(name=loop_name + "_after_bb")
-
-        self.builder.cbranch(cond, loop_bb, after_bb)
-        phi.add_incoming(next_var, loop_end_bb)
-
-        self.builder.position_at_end(loop_bb)
-
-        return loop_end_bb, after_bb, phi
-
-    def __exit__(self, exc_type, exc, exc_tb):
-        self.builder.branch(self.loop_end)
-        self.builder.position_at_end(self.after)

pystencils/llvm/kernelcreation.py

-from pystencils.enums import Target, Backend
-from pystencils.llvm.llvmjit import make_python_function
-from pystencils.transformations import insert_casts
-
-
-def create_kernel(assignments, function_name="kernel", type_info=None, split_groups=(),
-                  iteration_slice=None, ghost_layers=None, target=Target.CPU):
-    """
-    Creates an abstract syntax tree for a kernel function, by taking a list of update rules.
-
-    Loops are created according to the field accesses in the equations.
-
-    Args:
-    assignments: list of sympy equations, containing accesses to :class:`pystencils.field.Field`.
-                 Defining the update rules of the kernel
-    function_name: name of the generated function - only important if generated code is written out
-                   type_info: a map from symbol name to a C type specifier. If not specified all symbols are assumed to
-                   be of type 'double' except symbols which occur on the left hand side of equations where the
-                   right hand side is a sympy Boolean which are assumed to be 'bool' .
-    split_groups: Specification on how to split up inner loop into multiple loops. For details see
-                  transformation :func:`pystencils.transformation.split_inner_loop`
-    iteration_slice: if not None, iteration is done only over this slice of the field
-    ghost_layers: a sequence of pairs for each coordinate with lower and upper nr of ghost layers
-                 if None, the number of ghost layers is determined automatically and assumed to be equal for a
-                 all dimensions
-
-    :return: :class:`pystencils.ast.KernelFunction` node
-    """
-    if target == Target.CPU:
-        from pystencils.cpu import create_kernel
-        code = create_kernel(assignments, function_name, type_info, split_groups, iteration_slice, ghost_layers)
-    elif target == Target.GPU:
-        from pystencils.gpucuda.kernelcreation import create_cuda_kernel
-        code = create_cuda_kernel(assignments,
-                                  function_name,
-                                  type_info,
-                                  iteration_slice=iteration_slice,
-                                  ghost_layers=ghost_layers)
-    else:
-        NotImplementedError(f'{target} is not implemented for LLVM kernel creation')
-    code._backend = Backend.LLVM
-    code.body = insert_casts(code.body)
-    code._compile_function = make_python_function
-
-    return code

pystencils/llvm/llvm.py

-import functools
-
-import llvmlite.ir as ir
-import llvmlite.llvmpy.core as lc
-import sympy as sp
-from sympy import Indexed, S
-from sympy.printing.printer import Printer
-
-from pystencils import Target
-from pystencils.assignment import Assignment
-from pystencils.data_types import (
-    collate_types, create_composite_type_from_string, create_type, get_type_of_expression,
-    to_llvm_type)
-from pystencils.llvm.control_flow import Loop
-
-
-# From Numba
-def set_cuda_kernel(lfunc):
-    from llvmlite.llvmpy.core import MetaData, MetaDataString, Constant, Type
-
-    m = lfunc.module
-
-    ops = lfunc, MetaDataString.get(m, "kernel"), Constant.int(Type.int(), 1)
-    md = MetaData.get(m, ops)
-
-    nmd = m.get_or_insert_named_metadata('nvvm.annotations')
-    nmd.add(md)
-
-    # set nvvm ir version
-    i32 = ir.IntType(32)
-    md_ver = m.add_metadata([i32(1), i32(2), i32(2), i32(0)])
-    m.add_named_metadata('nvvmir.version', md_ver)
-
-
-# From Numba
-def _call_sreg(builder, name):
-    module = builder.module
-    fnty = lc.Type.function(lc.Type.int(), ())
-    fn = module.get_or_insert_function(fnty, name=name)
-    return builder.call(fn, ())
-
-
-def generate_llvm(ast_node, module=None, builder=None, target=Target.CPU):
-    """Prints the ast as llvm code."""
-    if module is None:
-        module = lc.Module()
-    if builder is None:
-        builder = ir.IRBuilder()
-    printer = LLVMPrinter(module, builder, target=target)
-    return printer._print(ast_node)
-
-
-# noinspection PyPep8Naming
-class LLVMPrinter(Printer):
-    """Convert expressions to LLVM IR"""
-
-    def __init__(self, module, builder, fn=None, target=Target.CPU, *args, **kwargs):
-        self.func_arg_map = kwargs.pop("func_arg_map", {})
-        super(LLVMPrinter, self).__init__(*args, **kwargs)
-        self.fp_type = ir.DoubleType()
-        self.fp_pointer = self.fp_type.as_pointer()
-        self.integer = ir.IntType(64)
-        self.integer_pointer = self.integer.as_pointer()
-        self.void = ir.VoidType()
-        self.module = module
-        self.builder = builder
-        self.fn = fn
-        self.ext_fn = {}  # keep track of wrappers to external functions
-        self.tmp_var = {}
-        self.target = target
-
-    def _add_tmp_var(self, name, value):
-        self.tmp_var[name] = value
-
-    def _remove_tmp_var(self, name):
-        del self.tmp_var[name]
-
-    def _print_Number(self, n):
-        if get_type_of_expression(n) == create_type("int"):
-            return ir.Constant(self.integer, int(n))
-        elif get_type_of_expression(n) == create_type("double"):
-            return ir.Constant(self.fp_type, float(n))
-        else:
-            raise NotImplementedError("Numbers can only have int and double", n)
-
-    def _print_Float(self, expr):
-        return ir.Constant(self.fp_type, float(expr))
-
-    def _print_Integer(self, expr):
-        return ir.Constant(self.integer, int(expr))
-
-    def _print_int(self, i):
-        return ir.Constant(self.integer, i)
-
-    def _print_Symbol(self, s):
-        val = self.tmp_var.get(s)
-        if not val:
-            # look up parameter with name s
-            val = self.func_arg_map.get(s.name)
-        if not val:
-            raise LookupError(f"Symbol not found: {s}")
-        return val
-
-    def _print_Pow(self, expr):
-        base0 = self._print(expr.base)
-        if expr.exp == S.NegativeOne:
-            return self.builder.fdiv(ir.Constant(self.fp_type, 1.0), base0)
-        if expr.exp == S.Half:
-            fn = self.ext_fn.get("sqrt")
-            if not fn:
-                fn_type = ir.FunctionType(self.fp_type, [self.fp_type])
-                fn = ir.Function(self.module, fn_type, "sqrt")
-                self.ext_fn["sqrt"] = fn
-            return self.builder.call(fn, [base0], "sqrt")
-        if expr.exp == 2:
-            return self.builder.fmul(base0, base0)
-        elif expr.exp == 3:
-            return self.builder.fmul(self.builder.fmul(base0, base0), base0)
-
-        exp0 = self._print(expr.exp)
-        fn = self.ext_fn.get("pow")
-        if not fn:
-            fn_type = ir.FunctionType(self.fp_type, [self.fp_type, self.fp_type])
-            fn = ir.Function(self.module, fn_type, "pow")
-            self.ext_fn["pow"] = fn
-        return self.builder.call(fn, [base0, exp0], "pow")
-
-    def _print_Mul(self, expr):
-        nodes = [self._print(a) for a in expr.args]
-        e = nodes[0]
-        if get_type_of_expression(expr) == create_type('double'):
-            mul = self.builder.fmul
-        else:  # int TODO unsigned/signed
-            mul = self.builder.mul
-        for node in nodes[1:]:
-            e = mul(e, node)
-        return e
-
-    def _print_Add(self, expr):
-        nodes = [self._print(a) for a in expr.args]
-        e = nodes[0]
-        if get_type_of_expression(expr) == create_type('double'):
-            add = self.builder.fadd
-        else:  # int TODO unsigned/signed
-            add = self.builder.add
-        for node in nodes[1:]:
-            e = add(e, node)
-        return e
-
-    def _print_Or(self, expr):
-        nodes = [self._print(a) for a in expr.args]
-        e = nodes[0]
-        for node in nodes[1:]:
-            e = self.builder.or_(e, node)
-        return e
-
-    def _print_And(self, expr):
-        nodes = [self._print(a) for a in expr.args]
-        e = nodes[0]
-        for node in nodes[1:]:
-            e = self.builder.and_(e, node)
-        return e
-
-    def _print_StrictLessThan(self, expr):
-        return self._comparison('<', expr)
-
-    def _print_LessThan(self, expr):
-        return self._comparison('<=', expr)
-
-    def _print_StrictGreaterThan(self, expr):
-        return self._comparison('>', expr)
-
-    def _print_GreaterThan(self, expr):
-        return self._comparison('>=', expr)
-
-    def _print_Unequality(self, expr):
-        return self._comparison('!=', expr)
-
-    def _print_Equality(self, expr):
-        return self._comparison('==', expr)
-
-    def _comparison(self, cmpop, expr):
-        if collate_types([get_type_of_expression(arg) for arg in expr.args]) == create_type('double'):
-            comparison = self.builder.fcmp_unordered
-        else:
-            comparison = self.builder.icmp_signed
-        return comparison(cmpop, self._print(expr.lhs), self._print(expr.rhs))
-
-    def _print_KernelFunction(self, func):
-        # KernelFunction does not posses a return type
-        return_type = self.void
-        parameter_type = []
-        parameters = func.get_parameters()
-        for parameter in parameters:
-            parameter_type.append(to_llvm_type(parameter.symbol.dtype, nvvm_target=self.target == Target.GPU))
-        func_type = ir.FunctionType(return_type, tuple(parameter_type))
-        name = func.function_name
-        fn = ir.Function(self.module, func_type, name)
-        self.ext_fn[name] = fn
-
-        # set proper names to arguments
-        for i, arg in enumerate(fn.args):
-            arg.name = parameters[i].symbol.name
-            self.func_arg_map[parameters[i].symbol.name] = arg
-
-        # func.attributes.add("inlinehint")
-        # func.attributes.add("argmemonly")
-        block = fn.append_basic_block(name="entry")
-        self.builder = ir.IRBuilder(block)  # TODO use goto_block instead
-        self._print(func.body)
-        self.builder.ret_void()
-        self.fn = fn
-        if self.target == Target.GPU:
-            set_cuda_kernel(fn)
-
-        return fn
-
-    def _print_Block(self, block):
-        for node in block.args:
-            self._print(node)
-
-    def _print_LoopOverCoordinate(self, loop):
-        with Loop(self.builder, self._print(loop.start), self._print(loop.stop), self._print(loop.step),
-                  loop.loop_counter_name, loop.loop_counter_symbol.name) as i:
-            self._add_tmp_var(loop.loop_counter_symbol, i)
-            self._print(loop.body)
-            self._remove_tmp_var(loop.loop_counter_symbol)
-
-    def _print_SympyAssignment(self, assignment):
-        expr = self._print(assignment.rhs)
-        lhs = assignment.lhs
-        if isinstance(lhs, Indexed):
-            ptr = self._print(lhs.base.label)
-            index = self._print(lhs.args[1])
-            gep = self.builder.gep(ptr, [index])
-            return self.builder.store(expr, gep)
-        self.func_arg_map[assignment.lhs.name] = expr
-        return expr
-
-    def _print_boolean_cast_func(self, conversion):
-        return self._print_cast_func(conversion)
-
-    def _print_cast_func(self, conversion):
-        node = self._print(conversion.args[0])
-        to_dtype = get_type_of_expression(conversion)
-        from_dtype = get_type_of_expression(conversion.args[0])
-        if from_dtype == to_dtype:
-            return self._print(conversion.args[0])
-
-        # (From, to)
-        decision = {
-            (create_composite_type_from_string("int32"),
-             create_composite_type_from_string("int64")): functools.partial(self.builder.zext, node, self.integer),
-            (create_composite_type_from_string("int16"),
-             create_composite_type_from_string("int64")): functools.partial(self.builder.zext, node, self.integer),
-            (create_composite_type_from_string("int"),
-             create_composite_type_from_string("double")): functools.partial(self.builder.sitofp, node, self.fp_type),
-            (create_composite_type_from_string("int16"),
-             create_composite_type_from_string("double")): functools.partial(self.builder.sitofp, node, self.fp_type),
-            (create_composite_type_from_string("double"),
-             create_composite_type_from_string("int")): functools.partial(self.builder.fptosi, node, self.integer),
-            (create_composite_type_from_string("double *"),
-             create_composite_type_from_string("int")): functools.partial(self.builder.ptrtoint, node, self.integer),
-            (create_composite_type_from_string("int"),
-             create_composite_type_from_string("double *")): functools.partial(self.builder.inttoptr,
-                                                                               node, self.fp_pointer),
-            (create_composite_type_from_string("double * restrict"),
-             create_composite_type_from_string("int")): functools.partial(self.builder.ptrtoint, node, self.integer),
-            (create_composite_type_from_string("int"),
-             create_composite_type_from_string("double * restrict")): functools.partial(self.builder.inttoptr, node,
-                                                                                        self.fp_pointer),
-            (create_composite_type_from_string("double * restrict const"),
-             create_composite_type_from_string("int")): functools.partial(self.builder.ptrtoint, node,
-                                                                          self.integer),
-            (create_composite_type_from_string("int"),
-             create_composite_type_from_string("double * restrict const")): functools.partial(self.builder.inttoptr,
-                                                                                              node, self.fp_pointer),
-        }
-        # TODO float, TEST: const, restrict
-        # TODO bitcast, addrspacecast
-        # TODO unsigned/signed fills
-        # print([x for x in decision.keys()])
-        # print("Types:")
-        # print([(type(x), type(y)) for (x, y) in decision.keys()])
-        # print("Cast:")
-        # print((from_dtype, to_dtype))
-        return decision[(from_dtype, to_dtype)]()
-
-    def _print_pointer_arithmetic_func(self, pointer):
-        ptr = self._print(pointer.args[0])
-        index = self._print(pointer.args[1])
-        return self.builder.gep(ptr, [index])
-
-    def _print_Indexed(self, indexed):
-        ptr = self._print(indexed.base.label)
-        index = self._print(indexed.args[1])
-        gep = self.builder.gep(ptr, [index])
-        return self.builder.load(gep, name=indexed.base.label.name)
-
-    def _print_Piecewise(self, piece):
-        if not piece.args[-1].cond:
-            # We need the last conditional to be a True, otherwise the resulting
-            # function may not return a result.
-            raise ValueError("All Piecewise expressions must contain an "
-                             "(expr, True) statement to be used as a default "
-                             "condition. Without one, the generated "
-                             "expression may not evaluate to anything under "
-                             "some condition.")
-        if piece.has(Assignment):
-            raise NotImplementedError('The llvm-backend does not support assignments'
-                                      'in the Piecewise function. It is questionable'
-                                      'whether to implement it. So far there is no'
-                                      'use-case to test it.')
-        else:
-            phi_data = []
-            after_block = self.builder.append_basic_block()
-            for (expr, condition) in piece.args:
-                if condition == sp.sympify(True):  # Don't use 'is' use '=='!
-                    phi_data.append((self._print(expr), self.builder.block))
-                    self.builder.branch(after_block)
-                    self.builder.position_at_end(after_block)
-                else:
-                    cond = self._print(condition)
-                    true_block = self.builder.append_basic_block()
-                    false_block = self.builder.append_basic_block()
-                    self.builder.cbranch(cond, true_block, false_block)
-                    self.builder.position_at_end(true_block)
-                    phi_data.append((self._print(expr), true_block))
-                    self.builder.branch(after_block)
-                    self.builder.position_at_end(false_block)
-
-            phi = self.builder.phi(to_llvm_type(get_type_of_expression(piece), nvvm_target=self.target == Target.GPU))
-            for (val, block) in phi_data:
-                phi.add_incoming(val, block)
-            return phi
-
-    def _print_Conditional(self, node):
-        cond = self._print(node.condition_expr)
-        with self.builder.if_else(cond) as (then, otherwise):
-            with then:
-                self._print(node.true_block)       # emit instructions for when the predicate is true
-            with otherwise:
-                self._print(node.false_block)       # emit instructions for when the predicate is true
-
-        # No return!
-
-    def _print_Function(self, expr):
-        name = expr.func.__name__
-        e0 = self._print(expr.args[0])
-        fn = self.ext_fn.get(name)
-        if not fn:
-            fn_type = ir.FunctionType(self.fp_type, [self.fp_type])
-            fn = ir.Function(self.module, fn_type, name)
-            self.ext_fn[name] = fn
-        return self.builder.call(fn, [e0], name)
-
-    def empty_printer(self, expr):
-        try:
-            import inspect
-            mro = inspect.getmro(expr)
-        except AttributeError:
-            mro = "None"
-        raise TypeError("Unsupported type for LLVM JIT conversion: Expression:\"%s\", Type:\"%s\", MRO:%s"
-                        % (expr, type(expr), mro))
-
-    # from: https://llvm.org/docs/NVPTXUsage.html#nvptx-intrinsics
-    INDEXING_FUNCTION_MAPPING = {
-        'blockIdx': 'llvm.nvvm.read.ptx.sreg.ctaid',
-        'threadIdx': 'llvm.nvvm.read.ptx.sreg.tid',
-        'blockDim': 'llvm.nvvm.read.ptx.sreg.ntid',
-        'gridDim': 'llvm.nvvm.read.ptx.sreg.nctaid'
-    }
-
-    def _print_ThreadIndexingSymbol(self, node):
-        symbol_name: str = node.name
-        function_name, dimension = tuple(symbol_name.split("."))
-        function_name = self.INDEXING_FUNCTION_MAPPING[function_name]
-        name = f"{function_name}.{dimension}"
-
-        return self.builder.zext(_call_sreg(self.builder, name), self.integer)

pystencils/llvm/llvmjit.py

-import ctypes as ct
-import subprocess
-from functools import partial
-from itertools import chain
-from os.path import exists, join
-
-import llvmlite.binding as llvm
-import llvmlite.ir as ir
-import numpy as np
-
-from pystencils.data_types import create_composite_type_from_string
-from pystencils.enums import Target
-from pystencils.field import FieldType
-
-from ..data_types import StructType, ctypes_from_llvm, to_ctypes
-from .llvm import generate_llvm
-
-
-def build_ctypes_argument_list(parameter_specification, argument_dict):
-    argument_dict = {k: v for k, v in argument_dict.items()}
-    ct_arguments = []
-    array_shapes = set()
-    index_arr_shapes = set()
-
-    for param in parameter_specification:
-        if param.is_field_parameter:
-            try:
-                field_arr = argument_dict[param.field_name]
-            except KeyError:
-                raise KeyError("Missing field parameter for kernel call " + param.field_name)
-
-            symbolic_field = param.fields[0]
-            if param.is_field_pointer:
-                ct_arguments.append(field_arr.ctypes.data_as(to_ctypes(param.symbol.dtype)))
-                if symbolic_field.has_fixed_shape:
-                    symbolic_field_shape = tuple(int(i) for i in symbolic_field.shape)
-                    if isinstance(symbolic_field.dtype, StructType):
-                        symbolic_field_shape = symbolic_field_shape[:-1]
-                    if symbolic_field_shape != field_arr.shape:
-                        raise ValueError("Passed array '%s' has shape %s which does not match expected shape %s" %
-                                         (param.field_name, str(field_arr.shape), str(symbolic_field.shape)))
-                if symbolic_field.has_fixed_shape:
-                    symbolic_field_strides = tuple(int(i) * field_arr.itemsize for i in symbolic_field.strides)
-                    if isinstance(symbolic_field.dtype, StructType):
-                        symbolic_field_strides = symbolic_field_strides[:-1]
-                    if symbolic_field_strides != field_arr.strides:
-                        raise ValueError("Passed array '%s' has strides %s which does not match expected strides %s" %
-                                         (param.field_name, str(field_arr.strides), str(symbolic_field_strides)))
-
-                if FieldType.is_indexed(symbolic_field):
-                    index_arr_shapes.add(field_arr.shape[:symbolic_field.spatial_dimensions])
-                elif FieldType.is_generic(symbolic_field):
-                    array_shapes.add(field_arr.shape[:symbolic_field.spatial_dimensions])
-
-            elif param.is_field_shape:
-                data_type = to_ctypes(param.symbol.dtype)
-                ct_arguments.append(data_type(field_arr.shape[param.symbol.coordinate]))
-            elif param.is_field_stride:
-                data_type = to_ctypes(param.symbol.dtype)
-                assert field_arr.strides[param.symbol.coordinate] % field_arr.itemsize == 0
-                item_stride = field_arr.strides[param.symbol.coordinate] // field_arr.itemsize
-                ct_arguments.append(data_type(item_stride))
-            else:
-                assert False
-        else:
-            try:
-                value = argument_dict[param.symbol.name]
-            except KeyError:
-                raise KeyError("Missing parameter for kernel call " + param.symbol.name)
-            expected_type = to_ctypes(param.symbol.dtype)
-            ct_arguments.append(expected_type(value))
-
-    if len(array_shapes) > 1:
-        raise ValueError("All passed arrays have to have the same size " + str(array_shapes))
-    if len(index_arr_shapes) > 1:
-        raise ValueError("All passed index arrays have to have the same size " + str(array_shapes))
-
-    return ct_arguments
-
-
-def make_python_function_incomplete_params(kernel_function_node, argument_dict, func):
-    parameters = kernel_function_node.get_parameters()
-
-    cache = {}
-    cache_values = []
-
-    def wrapper(**kwargs):
-        key = hash(tuple((k, v.ctypes.data, v.strides, v.shape) if isinstance(v, np.ndarray) else (k, id(v))
-                         for k, v in kwargs.items()))
-        try:
-            args = cache[key]
-            func(*args)
-        except KeyError:
-            full_arguments = argument_dict.copy()
-            full_arguments.update(kwargs)
-            args = build_ctypes_argument_list(parameters, full_arguments)
-            cache[key] = args
-            cache_values.append(kwargs)  # keep objects alive such that ids remain unique
-            func(*args)
-    wrapper.ast = kernel_function_node
-    wrapper.parameters = kernel_function_node.get_parameters()
-    return wrapper
-
-
-def generate_and_jit(ast):
-    target = ast.target
-    gen = generate_llvm(ast, target=target)
-    if isinstance(gen, ir.Module):
-        return compile_llvm(gen, target, ast)
-    else:
-        return compile_llvm(gen.module, target, ast)
-
-
-def make_python_function(ast, argument_dict=None, func=None):
-    if argument_dict is None:
-        argument_dict = {}
-    if func is None:
-        jit = generate_and_jit(ast)
-        func = jit.get_function_ptr(ast.function_name)
-    try:
-        args = build_ctypes_argument_list(ast.get_parameters(), argument_dict)
-    except KeyError:
-        # not all parameters specified yet
-        return make_python_function_incomplete_params(ast, argument_dict, func)
-    return lambda: func(*args)
-
-
-def compile_llvm(module, target=Target.CPU, ast=None):
-    jit = CudaJit(ast) if target == Target.GPU else Jit()
-    jit.parse(module)
-    jit.optimize()
-    jit.compile()
-    return jit
-
-
-class Jit(object):
-    def __init__(self):
-        llvm.initialize()
-        llvm.initialize_all_targets()
-        llvm.initialize_native_target()
-        llvm.initialize_native_asmprinter()
-
-        self.module = None
-        self._llvmmod = llvm.parse_assembly("")
-        self.target = llvm.Target.from_default_triple()
-        self.cpu = llvm.get_host_cpu_name()
-        try:
-            self.cpu_features = llvm.get_host_cpu_features()
-            self.target_machine = self.target.create_target_machine(cpu=self.cpu, features=self.cpu_features.flatten(),
-                                                                    opt=2)
-        except RuntimeError:
-            self.target_machine = self.target.create_target_machine(cpu=self.cpu, opt=2)
-        llvm.check_jit_execution()
-        self.ee = llvm.create_mcjit_compiler(self.llvmmod, self.target_machine)
-        self.ee.finalize_object()
-        self.fptr = None
-
-    @property
-    def llvmmod(self):
-        return self._llvmmod
-
-    @llvmmod.setter
-    def llvmmod(self, mod):
-        self.ee.remove_module(self.llvmmod)
-        self.ee.add_module(mod)
-        self.ee.finalize_object()
-        self.compile()
-        self._llvmmod = mod
-
-    def parse(self, module):
-        self.module = module
-        llvmmod = llvm.parse_assembly(str(module))
-        llvmmod.verify()
-        llvmmod.triple = self.target.triple
-        llvmmod.name = 'module'
-        self.llvmmod = llvmmod
-
-    def write_ll(self, file):
-        with open(file, 'w') as f:
-            f.write(str(self.llvmmod))
-
-    def write_assembly(self, file):
-        with open(file, 'w') as f:
-            f.write(self.target_machine.emit_assembly(self.llvmmod))
-
-    def write_object_file(self, file):
-        with open(file, 'wb') as f:
-            f.write(self.target_machine.emit_object(self.llvmmod))
-
-    def optimize(self):
-        pmb = llvm.create_pass_manager_builder()
-        pmb.opt_level = 2
-        pmb.disable_unit_at_a_time = False
-        pmb.loop_vectorize = True
-        pmb.slp_vectorize = True
-        # TODO possible to pass for functions
-        pm = llvm.create_module_pass_manager()
-        pm.add_instruction_combining_pass()
-        pm.add_function_attrs_pass()
-        pm.add_constant_merge_pass()
-        pm.add_licm_pass()
-        pmb.populate(pm)
-        pm.run(self.llvmmod)
-
-    def compile(self):
-        fptr = {}
-        for func in self.module.functions:
-            if not func.is_declaration:
-                return_type = None
-                if func.ftype.return_type != ir.VoidType():
-                    return_type = to_ctypes(create_composite_type_from_string(str(func.ftype.return_type)))
-                args = [ctypes_from_llvm(arg) for arg in func.ftype.args]
-                function_address = self.ee.get_function_address(func.name)
-                fptr[func.name] = ct.CFUNCTYPE(return_type, *args)(function_address)
-        self.fptr = fptr
-
-    def __call__(self, func, *args, **kwargs):
-        target_function = next(f for f in self.module.functions if f.name == func)
-        arg_types = [ctypes_from_llvm(arg.type) for arg in target_function.args]
-
-        transformed_args = []
-        for i, arg in enumerate(args):
-            if isinstance(arg, np.ndarray):
-                transformed_args.append(arg.ctypes.data_as(arg_types[i]))
-            else:
-                transformed_args.append(arg)
-
-        self.fptr[func](*transformed_args)
-
-    def print_functions(self):
-        for f in self.module.functions:
-            print(f.ftype.return_type, f.name, f.args)
-
-    def get_function_ptr(self, name):
-        fptr = self.fptr[name]
-        fptr.jit = self
-        return fptr
-
-
-# Following code more or less from numba
-class CudaJit(Jit):
-
-    CUDA_TRIPLE = {32: 'nvptx-nvidia-cuda',
-                   64: 'nvptx64-nvidia-cuda'}
-    MACHINE_BITS = tuple.__itemsize__ * 8
-    data_layout = {
-        32: ('e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-'
-             'f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64'),
-        64: ('e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-'
-             'f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64')}
-
-    default_data_layout = data_layout[MACHINE_BITS]
-
-    def __init__(self, ast):
-        # super().__init__()
-
-        # self.target = llvm.Target.from_triple(self.CUDA_TRIPLE[self.MACHINE_BITS])
-        self._data_layout = self.default_data_layout[self.MACHINE_BITS]
-        # self._target_data = llvm.create_target_data(self._data_layout)
-        self.indexing = ast.indexing
-
-    def optimize(self):
-        pmb = llvm.create_pass_manager_builder()
-        pmb.opt_level = 2
-        pmb.disable_unit_at_a_time = False
-        pmb.loop_vectorize = False
-        pmb.slp_vectorize = False
-        # TODO possible to pass for functions
-        pm = llvm.create_module_pass_manager()
-        pm.add_instruction_combining_pass()
-        pm.add_function_attrs_pass()
-        pm.add_constant_merge_pass()
-        pm.add_licm_pass()
-        pmb.populate(pm)
-        pm.run(self.llvmmod)
-        pm.run(self.llvmmod)
-
-    def write_ll(self, file):
-        with open(file, 'w') as f:
-            f.write(str(self.llvmmod))
-
-    def parse(self, module):
-
-        llvmmod = module
-        llvmmod.triple = self.CUDA_TRIPLE[self.MACHINE_BITS]
-        llvmmod.data_layout = self.default_data_layout
-        llvmmod.verify()
-        llvmmod.name = 'module'
-
-        self._llvmmod = llvm.parse_assembly(str(llvmmod))
-
-    def compile(self):
-        from pystencils.cpu.cpujit import get_cache_config, get_compiler_config, get_llc_command
-        import hashlib
-        compiler_cache = get_cache_config()['object_cache']
-        ir_file = join(compiler_cache, hashlib.md5(str(self._llvmmod).encode()).hexdigest() + '.ll')
-        ptx_file = ir_file.replace('.ll', '.ptx')
-        try:
-            from pycuda.driver import Context
-            arch = "sm_%d%d" % Context.get_device().compute_capability()
-        except Exception:
-            arch = "sm_35"
-
-        if not exists(ptx_file):
-            self.write_ll(ir_file)
-            if 'llc' in get_compiler_config():
-                llc_command = get_compiler_config()['llc']
-            else:
-                llc_command = get_llc_command() or 'llc'
-
-            subprocess.check_call([llc_command, '-mcpu=' + arch, ir_file, '-o', ptx_file])
-
-        # cubin_file = ir_file.replace('.ll', '.cubin')
-        # if not exists(cubin_file):
-            # subprocess.check_call(['ptxas', '--gpu-name', arch, ptx_file, '-o', cubin_file])
-        import pycuda.driver
-
-        cuda_module = pycuda.driver.module_from_file(ptx_file)  # also works: cubin_file
-        self.cuda_module = cuda_module
-
-    def __call__(self, func, *args, **kwargs):
-        shape = [a.shape for a in chain(args, kwargs.values()) if hasattr(a, 'shape')][0]
-        block_and_thread_numbers = self.indexing.call_parameters(shape)
-        block_and_thread_numbers['block'] = tuple(int(i) for i in block_and_thread_numbers['block'])
-        block_and_thread_numbers['grid'] = tuple(int(i) for i in block_and_thread_numbers['grid'])
-        self.cuda_module.get_function(func)(*args, **kwargs, **block_and_thread_numbers)
-
-    def get_function_ptr(self, name):
-        return partial(self._call__, name)

pystencils_tests/test_llvm.py

-
-import pytest
-try:
-    from pystencils.llvm.llvmjit import generate_and_jit
-    from pystencils.llvm import create_kernel, make_python_function
-    from pystencils.cpu.cpujit import get_llc_command
-    from pystencils import Assignment, Field, Target
-    import numpy as np
-    import sympy as sp
-except ModuleNotFoundError:
-    pytest.importorskip("llvmlite")
-
-
-def test_jacobi_fixed_field_size():
-    size = (30, 20)
-
-    src_field_llvm = np.random.rand(*size)
-    src_field_py = np.copy(src_field_llvm)
-    dst_field_llvm = np.zeros(size)
-    dst_field_py = np.zeros(size)
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    jacobi = Assignment(d[0, 0], (f[1, 0] + f[-1, 0] + f[0, 1] + f[0, -1]) / 4)
-    ast = create_kernel([jacobi])
-
-    for x in range(1, size[0] - 1):
-        for y in range(1, size[1] - 1):
-            dst_field_py[x, y] = 0.25 * (src_field_py[x - 1, y] + src_field_py[x + 1, y] +
-                                         src_field_py[x, y - 1] + src_field_py[x, y + 1])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    error = np.sum(np.abs(dst_field_py - dst_field_llvm))
-    np.testing.assert_almost_equal(error, 0.0)
-
-
-@pytest.mark.skipif(not get_llc_command(), reason="Tests requires llc in $PATH")
-def test_jacobi_fixed_field_size_gpu():
-    pytest.importorskip("pycuda")
-    size = (30, 20)
-
-    import pycuda.autoinit  # noqa
-    from pycuda.gpuarray import to_gpu
-
-    src_field_llvm = np.random.rand(*size)
-    src_field_py = np.copy(src_field_llvm)
-    dst_field_llvm = np.zeros(size)
-    dst_field_py = np.zeros(size)
-
-    f = Field.create_from_numpy_array("f", src_field_py)
-    d = Field.create_from_numpy_array("d", dst_field_py)
-
-    src_field_llvm = to_gpu(src_field_llvm)
-    dst_field_llvm = to_gpu(dst_field_llvm)
-
-    jacobi = Assignment(d[0, 0], (f[1, 0] + f[-1, 0] + f[0, 1] + f[0, -1]) / 4)
-    ast = create_kernel([jacobi], target=Target.GPU)
-
-    for x in range(1, size[0] - 1):
-        for y in range(1, size[1] - 1):
-            dst_field_py[x, y] = 0.25 * (src_field_py[x - 1, y] + src_field_py[x + 1, y] +
-                                         src_field_py[x, y - 1] + src_field_py[x, y + 1])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    error = np.sum(np.abs(dst_field_py - dst_field_llvm.get()))
-    np.testing.assert_almost_equal(error, 0.0)
-
-
-def test_jacobi_variable_field_size():
-    size = (3, 3, 3)
-    f = Field.create_generic("f", 3)
-    d = Field.create_generic("d", 3)
-    jacobi = Assignment(d[0, 0, 0], (f[1, 0, 0] + f[-1, 0, 0] + f[0, 1, 0] + f[0, -1, 0]) / 4)
-    ast = create_kernel([jacobi])
-
-    src_field_llvm = np.random.rand(*size)
-    src_field_py = np.copy(src_field_llvm)
-    dst_field_llvm = np.zeros(size)
-    dst_field_py = np.zeros(size)
-
-    for x in range(1, size[0] - 1):
-        for y in range(1, size[1] - 1):
-            for z in range(1, size[2] - 1):
-                dst_field_py[x, y, z] = 0.25 * (src_field_py[x - 1, y, z] + src_field_py[x + 1, y, z] +
-                                                src_field_py[x, y - 1, z] + src_field_py[x, y + 1, z])
-
-    kernel = make_python_function(ast, {'f': src_field_llvm, 'd': dst_field_llvm})
-    kernel()
-    error = np.sum(np.abs(dst_field_py - dst_field_llvm))
-    np.testing.assert_almost_equal(error, 0.0)
-
-
-def test_pow_llvm():
-    size = (30, 20)
-
-    src_field_llvm = 4 * np.ones(size)
-    dst_field_llvm = np.zeros(size)
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    ur = Assignment(d[0, 0], sp.Pow(f[0, 0], -1.0))
-    ast = create_kernel([ur])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    assert np.all(0.25 == dst_field_llvm)
-
-    ur = Assignment(d[0, 0], sp.Pow(f[0, 0], 0.5))
-    ast = create_kernel([ur])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    assert np.all(2.0 == dst_field_llvm)
-
-    ur = Assignment(d[0, 0], sp.Pow(f[0, 0], 2.0))
-    ast = create_kernel([ur])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    assert np.all(16.0 == dst_field_llvm)
-
-    ur = Assignment(d[0, 0], sp.Pow(f[0, 0], 3.0))
-    ast = create_kernel([ur])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    assert np.all(64.0 == dst_field_llvm)
-
-    ur = Assignment(d[0, 0], sp.Pow(f[0, 0], 4.0))
-    ast = create_kernel([ur])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    assert np.all(256.0 == dst_field_llvm)
-
-
-def test_piecewise_llvm():
-    size = (30, 20)
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    picewise_test_strict_less_than = Assignment(d[0, 0], sp.Piecewise((1.0, f[0, 0] > 10), (0.0, True)))
-    ast = create_kernel([picewise_test_strict_less_than])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[:, :] == 0.0))
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    picewise_test_less_than = Assignment(d[0, 0], sp.Piecewise((1.0, f[0, 0] >= 10), (0.0, True)))
-    ast = create_kernel([picewise_test_less_than])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[0:15, :] == 1.0))
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    picewise_test_strict_greater_than = Assignment(d[0, 0], sp.Piecewise((1.0, f[0, 0] < 5), (0.0, True)))
-    ast = create_kernel([picewise_test_strict_greater_than])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[15:, :] == 1.0))
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    picewise_test_greater_than = Assignment(d[0, 0], sp.Piecewise((1.0, f[0, 0] <= 10), (0.0, True)))
-    ast = create_kernel([picewise_test_greater_than])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[:, :] == 1.0))
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    picewise_test_equality = Assignment(d[0, 0], sp.Piecewise((1.0, sp.Equality(f[0, 0], 10.0)), (0.0, True)))
-    ast = create_kernel([picewise_test_equality])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[0:15, :] == 1.0))
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.0
-
-    picewise_test_unequality = Assignment(d[0, 0], sp.Piecewise((1.0, sp.Unequality(f[0, 0], 10.0)), (0.0, True)))
-    ast = create_kernel([picewise_test_unequality])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[15:, :] == 1.0))
-
-
-def test_piecewise_or_llvm():
-    size = (30, 20)
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 10.5
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    picewise_test_or = Assignment(d[0, 0], sp.Piecewise((1.0, sp.Or(f[0, 0] > 11, f[0, 0] < 10)), (0.0, True)))
-    ast = create_kernel([picewise_test_or])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[0:15, :] == 0.0))
-
-
-def test_print_function_llvm():
-    size = (30, 20)
-
-    src_field_llvm = np.zeros(size)
-    dst_field_llvm = np.zeros(size)
-
-    src_field_llvm[0:15, :] = 0.0
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    up = Assignment(d[0, 0], sp.sin(f[0, 0]))
-    ast = create_kernel([up])
-
-    # kernel = make_python_function(ast, {'f': src_field_llvm, 'd': dst_field_llvm})
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-
-    assert (np.all(dst_field_llvm[:, :] == 0.0))
-
-
-if __name__ == "__main__":
-    test_jacobi_fixed_field_size_gpu()

pystencils_tests/test_size_and_layout_checks_llvm.py

-import numpy as np
-import pytest
-
-from pystencils import Assignment, Field
-try:
-    from pystencils.llvm import create_kernel, make_python_function
-except ModuleNotFoundError:
-    pytest.importorskip("llvmlite")
-
-
-def test_size_check():
-    """Kernel with two fixed-sized fields creating with same size but calling with wrong size"""
-    src = np.zeros((20, 21, 9))
-    dst = np.zeros_like(src)
-
-    sym_src = Field.create_from_numpy_array("src", src, index_dimensions=1)
-    sym_dst = Field.create_from_numpy_array("dst", dst, index_dimensions=1)
-    update_rule = Assignment(sym_dst(0),
-                             sym_src[-1, 1](1) + sym_src[1, -1](2))
-    ast = create_kernel([update_rule])
-    func = make_python_function(ast)
-
-    # change size of src field
-    new_shape = [a - 7 for a in src.shape]
-    src = np.zeros(new_shape)
-    dst = np.zeros(new_shape)
-
-    try:
-        func(src=src, dst=dst)
-        assert False, "Expected ValueError because fields with different sized where passed"
-    except ValueError:
-        pass
-
-
-def test_fixed_size_mismatch_check():
-    """Create kernel with two differently sized but constant fields """
-    src = np.zeros((20, 21, 9))
-    dst = np.zeros((21, 21, 9))
-
-    sym_src = Field.create_from_numpy_array("src", src, index_dimensions=1)
-    sym_dst = Field.create_from_numpy_array("dst", dst, index_dimensions=1)
-    update_rule = Assignment(sym_dst(0),
-                             sym_src[-1, 1](1) + sym_src[1, -1](2))
-
-    try:
-        create_kernel([update_rule])
-        assert False, "Expected ValueError because fields with different sized where passed"
-    except ValueError:
-        pass
-
-
-def test_fixed_and_variable_field_check():
-    """Create kernel with two variable sized fields - calling them with different sizes"""
-    src = np.zeros((20, 21, 9))
-
-    sym_src = Field.create_from_numpy_array("src", src, index_dimensions=1)
-    sym_dst = Field.create_generic("dst", spatial_dimensions=2, index_dimensions=1)
-
-    update_rule = Assignment(sym_dst(0),
-                             sym_src[-1, 1](1) + sym_src[1, -1](2))
-
-    try:
-        create_kernel([update_rule])
-        assert False, "Expected ValueError because fields with different sized where passed"
-    except ValueError:
-        pass
-
-
-def test_two_variable_shaped_fields():
-    src = np.zeros((20, 21, 9))
-    dst = np.zeros((22, 21, 9))
-
-    sym_src = Field.create_generic("src", spatial_dimensions=2, index_dimensions=1)
-    sym_dst = Field.create_generic("dst", spatial_dimensions=2, index_dimensions=1)
-    update_rule = Assignment(sym_dst(0),
-                             sym_src[-1, 1](1) + sym_src[1, -1](2))
-
-    ast = create_kernel([update_rule])
-    func = make_python_function(ast)
-
-    try:
-        func(src=src, dst=dst)
-        assert False, "Expected ValueError because fields with different sized where passed"
-    except ValueError:
-        pass

pystencils_tests/test_sliced_iteration.py

@@ -27,31 +27,3 @@ def test_sliced_iteration():
     expected_result = np.zeros(size)
     expected_result[1:x_end_value, 1] = 1
     np.testing.assert_almost_equal(expected_result, dst_arr)
-
-
-def test_sliced_iteration_llvm():
-    import pytest
-    pytest.importorskip("llvmlite")
-    size = (4, 4)
-    src_arr = np.ones(size)
-    dst_arr = np.zeros_like(src_arr)
-    src_field = Field.create_from_numpy_array('src', src_arr)
-    dst_field = Field.create_from_numpy_array('dst', dst_arr)
-
-    a, b = sp.symbols("a b")
-    update_rule = Assignment(dst_field[0, 0],
-                             (a * src_field[0, 1] + a * src_field[0, -1] +
-                              b * src_field[1, 0] + b * src_field[-1, 0]) / 4)
-
-    x_end = TypedSymbol("x_end", "int")
-    s = make_slice[1:x_end, 1]
-    x_end_value = size[1] - 1
-    import pystencils.llvm as llvm_generator
-    ast = llvm_generator.create_kernel(sympy_cse_on_assignment_list([update_rule]), iteration_slice=s)
-    kernel = llvm_generator.make_python_function(ast)
-
-    kernel(src=src_arr, dst=dst_arr, a=1.0, b=1.0, x_end=x_end_value)
-
-    expected_result = np.zeros(size)
-    expected_result[1:x_end_value, 1] = 1
-    np.testing.assert_almost_equal(expected_result, dst_arr)

pystencils_tests/test_types.py

@@ -168,20 +168,6 @@ def test_pointer_arithmetic_func():
     assert pointer_arithmetic_func(TypedSymbol("s", np.uint), 1).canonical == TypedSymbol("s", np.uint).canonical
 
 
-def test_ctypes_from_llvm():
-    pytest.importorskip('llvmlite')
-    import llvmlite.ir as ir
-
-    ctypes_from_llvm(ir.VoidType())
-    assert ctypes_from_llvm(ir.IntType(8)) == ctypes.c_int8
-    assert ctypes_from_llvm(ir.IntType(16)) == ctypes.c_int16
-    assert ctypes_from_llvm(ir.IntType(32)) == ctypes.c_int32
-    assert ctypes_from_llvm(ir.IntType(64)) == ctypes.c_int64
-
-    assert ctypes_from_llvm(ir.FloatType()) == ctypes.c_float
-    assert ctypes_from_llvm(ir.DoubleType()) == ctypes.c_double
-
-
 def test_division():
     f = ps.fields('f(10): float32[2D]')
     m, tau = sp.symbols("m, tau")

setup.py

@@ -123,8 +123,7 @@ setuptools.setup(name='pystencils',
                      'doc': ['sphinx', 'sphinx_rtd_theme', 'nbsphinx',
                              'sphinxcontrib-bibtex', 'sphinx_autodoc_typehints', 'pandoc'],
                      'use_cython': ['Cython'],
-                     'kerncraft': ['osaca', 'kerncraft'],
-                     'llvm_jit': ['llvmlite']
+                     'kerncraft': ['osaca', 'kerncraft']
                  },
                  tests_require=['pytest',
                                 'pytest-cov',