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