yask_configuration = Parameters('yask')
yask_configuration.add('compiler', YaskCompiler())
callback = lambda i: eval(i) if i else ()
yask_configuration.add('folding', (), callback=callback, impacts_jit=False)
yask_configuration.add('blockshape', (), callback=callback, impacts_jit=False)
yask_configuration.add('clustering', (), callback=callback, impacts_jit=False)
yask_configuration.add('options', None, impacts_jit=False)
yask_configuration.add('dump', None, impacts_jit=False)
env_vars_mapper = {
'DEVITO_YASK_FOLDING': 'folding',
'DEVITO_YASK_BLOCKING': 'blockshape',
'DEVITO_YASK_CLUSTERING': 'clustering',
'DEVITO_YASK_OPTIONS': 'options',
'DEVITO_YASK_DUMP': 'dump'
}
add_sub_configuration(yask_configuration, env_vars_mapper)
# Add YASK-specific DLE modes
modes.add(Cpu64, {'advanced': YaskRewriter,
'speculative': YaskRewriter})
# The following used by backends.backendSelector
from devito.types import SparseFunction, SparseTimeFunction # noqa
from devito.yask.types import CacheManager, Grid, Constant, Function, TimeFunction # noqa
from devito.yask.operator import OperatorYASK as Operator # noqa
log("Backend successfully initialized!")
"""
The ``core`` Devito backend is simply a "shadow" of the ``base`` backend,
common to all other backends. The ``core`` backend (and therefore the ``base``
backend as well) are used to run Devito on standard CPU architectures.
"""
from devito.parameters import Parameters, add_sub_configuration
core_configuration = Parameters('core')
core_configuration.add('autotuning', 'basic', ['none', 'basic', 'aggressive'])
env_vars_mapper = {
'DEVITO_AUTOTUNING': 'autotuning',
}
add_sub_configuration(core_configuration, env_vars_mapper)
# The following used by backends.backendSelector
from devito.function import (
Constant,
Function,
TimeFunction,
SparseFunction, # noqa
SparseTimeFunction)
from devito.core.operator import Operator # noqa
from devito.types import CacheManager # noqa
from devito.archinfo import Cpu64, Intel64, Arm, Power, Device
from devito.core.cpu import (CPU64NoopOperator, CPU64Operator, Intel64Operator,
Intel64FSGOperator, ArmOperator, PowerOperator,
CustomOperator)
from devito.core.gpu_openmp import (DeviceOpenMPNoopOperator, DeviceOpenMPOperator,
DeviceOpenMPCustomOperator)
from devito.operator.registry import operator_registry
from devito.parameters import Parameters, add_sub_configuration
core_configuration = Parameters('core')
add_sub_configuration(core_configuration)
# Add core-specific Operators
operator_registry.add(CPU64NoopOperator, Cpu64, 'noop')
operator_registry.add(CPU64Operator, Cpu64, 'advanced')
operator_registry.add(CustomOperator, Cpu64, 'custom')
operator_registry.add(CPU64NoopOperator, Intel64, 'noop')
operator_registry.add(Intel64Operator, Intel64, 'advanced')
operator_registry.add(Intel64FSGOperator, Intel64, 'advanced-fsg')
operator_registry.add(CustomOperator, Intel64, 'custom')
operator_registry.add(CPU64NoopOperator, Arm, 'noop')
operator_registry.add(ArmOperator, Arm, 'advanced')
operator_registry.add(CustomOperator, Arm, 'custom')
operator_registry.add(CPU64NoopOperator, Power, 'noop')
operator_registry.add(PowerOperator, Power, 'advanced')
operator_registry.add(CustomOperator, Power, 'custom')
operator_registry.add(DeviceOpenMPNoopOperator, Device, 'noop')
"""
The ``ops`` Devito backend uses the OPS library to generate,
JIT-compile, and run kernels on multiple architectures.
"""
from devito.dle import (BasicRewriter, AdvancedRewriter, AdvancedRewriterSafeMath,
SpeculativeRewriter, init_dle)
from devito.parameters import Parameters, add_sub_configuration
ops_configuration = Parameters('ops')
env_vars_mapper = {}
add_sub_configuration(ops_configuration, env_vars_mapper)
# Initialize the DLE
modes = {'basic': BasicRewriter,
'advanced': AdvancedRewriter,
'advanced-safemath': AdvancedRewriterSafeMath,
'speculative': SpeculativeRewriter}
init_dle(modes)
# The following used by backends.backendSelector
from devito.ops.operator import OperatorOPS as Operator # noqa
from devito.types.constant import * # noqa
from devito.types.dense import * # noqa
from devito.types.sparse import * # noqa
from devito.types.basic import CacheManager # noqa
from devito.types.grid import Grid # noqa
"""
The ``core`` Devito backend is simply a "shadow" of the ``base`` backend,
common to all other backends. The ``core`` backend (and therefore the ``base``
backend as well) are used to run Devito on standard CPU architectures.
"""
from devito.archinfo import Cpu64, Intel64, Arm, Power, Device
from devito.dle import (CPU64Rewriter, Intel64Rewriter, ArmRewriter, PowerRewriter,
SpeculativeRewriter, DeviceOffloadingRewriter, modes)
from devito.parameters import Parameters, add_sub_configuration
core_configuration = Parameters('core')
env_vars_mapper = {}
add_sub_configuration(core_configuration, env_vars_mapper)
# Add core-specific DLE modes
modes.add(Cpu64, {'advanced': CPU64Rewriter,
'speculative': SpeculativeRewriter})
modes.add(Intel64, {'advanced': Intel64Rewriter,
'speculative': SpeculativeRewriter})
modes.add(Arm, {'advanced': ArmRewriter,
'speculative': SpeculativeRewriter})
modes.add(Power, {'advanced': PowerRewriter,
'speculative': SpeculativeRewriter})
modes.add(Device, {'advanced': DeviceOffloadingRewriter,
'speculative': DeviceOffloadingRewriter})
# The following used by backends.backendSelector
from devito.core.operator import OperatorCore as Operator # noqa
from devito.types.constant import * # noqa
from devito.types.dense import * # noqa
