modes = {
'basic': BasicRewriter,
'advanced': DevitoRewriter,
'advanced-safemath': DevitoRewriterSafeMath,
'speculative': DevitoSpeculativeRewriter
}
"""The DLE transformation modes."""
default_options = {
'blockinner': False,
'blockshape': None,
'blockalways': False
}
"""Default values for the various optimization options."""
configuration.add('dle', 'advanced', list(modes))
configuration.add('dle_options',
';'.join('%s:%s' % (k, v) for k, v in default_options.items()),
list(default_options))
def transform(node, mode='basic', options=None):
"""
Transform Iteration/Expression trees to generate highly optimized C code.
:param node: The Iteration/Expression tree to be transformed, or an iterable
of Iteration/Expression trees.
:param mode: Drive the tree transformation. ``mode`` is a string indicating
a certain optimization pipeline.
:param options: A dictionary with additional information to drive the DLE.
from __future__ import absolute_import
import weakref
import abc
import numpy as np
import sympy
from operator import mul
from functools import reduce
from devito.arguments import ScalarArgProvider, ArrayArgProvider, ObjectArgProvider
from devito.parameters import configuration
from devito.tools import single_or
__all__ = ['Symbol', 'Indexed']
configuration.add('first_touch', 0, [0, 1], lambda i: bool(i))
# This cache stores a reference to each created data object
# so that we may re-create equivalent symbols during symbolic
# manipulation with the correct shapes, pointers, etc.
_SymbolCache = {}
class Basic(object):
"""
Base class for API objects, used to build and run :class:`Operator`s.
There are two main types of objects: symbolic and generic. Symbolic objects
may carry data, and are used to build equations. Generic objects are used
to represent arbitrary data structures. The following diagram outlines the
top of this hierarchy.
'Compile log in %s\n'
'Compile errors in %s\n' %
(e.cmd, e.returncode, logfile, errfile))
# Registry dict for deriving Compiler classes according to the environment variable
# DEVITO_ARCH. Developers should add new compiler classes here.
compiler_registry = {
'custom': CustomCompiler,
'gcc': GNUCompiler,
'gnu': GNUCompiler,
'gcc-4.9': partial(GNUCompiler, version='4.9'),
'gcc-5': partial(GNUCompiler, version='5'),
'gcc-noavx': GNUCompilerNoAVX,
'gnu-noavx': GNUCompilerNoAVX,
'clang': ClangCompiler,
'osx': ClangCompiler,
'intel': IntelCompiler,
'icpc': IntelCompiler,
'icc': IntelCompiler,
'intel-mic': IntelMICCompiler,
'mic': IntelMICCompiler,
'intel-knl': IntelKNLCompiler,
'knl': IntelKNLCompiler,
}
configuration.add('compiler', 'custom', list(compiler_registry),
lambda i: compiler_registry[i]())
configuration.add('openmp', 0, [0, 1], lambda i: bool(i))
configuration.add('debug_compiler', 0, [0, 1], lambda i: bool(i))
from devito.dse.manipulation import cross_cluster_cse
from devito.logger import dse_warning
from devito.parameters import configuration
from devito.tools import flatten
__all__ = ['rewrite']
modes = {
'basic': BasicRewriter,
'advanced': AdvancedRewriter,
'speculative': SpeculativeRewriter,
'aggressive': AggressiveRewriter
}
"""The DSE transformation modes."""
configuration.add('dse', 'advanced', list(modes))
def rewrite(clusters, mode='advanced'):
"""
Given a sequence of N Clusters, produce a sequence of M Clusters with reduced
operation count, with M >= N.
Parameters
----------
clusters : list of Cluster
The Clusters to be transformed.
mode : str, optional
The aggressiveness of the rewrite. Accepted:
- ``noop``: Do nothing.
- ``basic``: Apply common sub-expressions elimination.
raise ValueError("Illegal logging level %s" % level)
if comm is not None and comm.rank != 0:
logger.removeHandler(stream_handler)
logger.addHandler(logging.NullHandler())
else:
logger.addHandler(stream_handler)
logger.setLevel(level)
def set_log_noperf():
"""Do not print performance-related messages."""
logger.setLevel(WARNING)
configuration.add('log_level', 'INFO', list(logger_registry),
lambda i: set_log_level(i))
class silencio(object):
"""
Decorator to temporarily change log levels.
"""
def __init__(self, log_level='WARNING'):
self.log_level = log_level
def __call__(self, func, *args, **kwargs):
@wraps(func)
def wrapper(*args, **kwargs):
previous = configuration['log_level']
configuration['log_level'] = self.log_level
result = func(*args, **kwargs)
warning("Couldn't set up `%s` profiler; reverting to `advanced`" %
level)
profiler = profiler_registry['basic'](name)
# We expect the `advanced` profiler to always initialize successfully
assert profiler.initialized
return profiler
# Set up profiling levels
profiler_registry = {
'basic': Profiler,
'advanced': AdvancedProfiler,
'advisor': AdvisorProfiler
}
configuration.add('profiling',
'basic',
list(profiler_registry),
impacts_jit=False)
def locate_intel_advisor():
try:
path = Path(os.environ['ADVISOR_HOME'])
# Little hack: assuming a 64bit system
if path.joinpath('bin64').joinpath('advixe-cl').is_file():
return path
else:
warning(
"Requested `advisor` profiler, but couldn't locate executable")
return None
except KeyError:
warning("Requested `advisor` profiler, but ADVISOR_HOME isn't set")
def clear_cache():
cache.clear_cache()
gc.collect()
for key, val in list(_SymbolCache.items()):
if val() is None:
del _SymbolCache[key]
from ._version import get_versions # noqa
__version__ = get_versions()['version']
del get_versions
# Initialize the Devito backend
configuration.add('travis_test', 0, [0, 1], lambda i: bool(i))
configuration.add('autotuning', 'basic', ['none', 'basic', 'aggressive'])
init_configuration()
init_backend(configuration['backend'])
def print_defaults():
"""Print the environment variables accepted by Devito, their default value,
as well as all of the accepted values."""
for k, v in env_vars_mapper.items():
info('%s: %s. Default: %s' %
(k, configuration._accepted[v], configuration._defaults[v]))
def print_state():
"""Print the current configuration state."""
"""
level = configuration['profiling']
profiler = profiler_registry[level](name)
if profiler.initialized:
return profiler
else:
warning("Couldn't set up `%s` profiler; reverting to `basic`" % level)
profiler = profiler_registry['basic'](name)
# We expect the `basic` profiler to always initialize successfully
assert profiler.initialized
return profiler
# Set up profiling levels
profiler_registry = {'basic': Profiler, 'advisor': AdvisorProfiler}
configuration.add('profiling', 'basic', list(profiler_registry))
def locate_intel_advisor():
try:
path = Path(os.environ['ADVISOR_HOME'])
# Little hack: assuming a 64bit system
if path.joinpath('bin64').joinpath('advixe-cl').is_file():
return path
else:
warning(
"Requested `advisor` profiler, but couldn't locate executable")
return None
except KeyError:
warning("Requested `advisor` profiler, but ADVISOR_HOME isn't set")
return None
# package.
mod = __import__('devito.%s' % backend, fromlist=['None'])
except ImportError as e:
warning('Unable to import backend %s' % backend)
raise e
backends[backend] = mod
_BackendSelector._backend = mod
def initialised_backend():
"""Check whether Devito has been yet initialised."""
return backends.get_backend() != 'void'
def init_backend(backend):
"""
Initialise Devito: select the backend and other configuration options.
"""
current_backend = get_backend()
if current_backend not in backends_registry:
raise RuntimeError(
"Calling init() for a different backend is illegal.")
if current_backend == 'void':
try:
set_backend(backend)
except (ImportError, RuntimeError):
raise DevitoError("Couldn't initialize Devito.")
configuration.add('backend', 'core', list(backends_registry))
