def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, Eq) for i in expressions):
raise InvalidOperator("Only `devito.Eq` expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
dse = kwargs.get("dse", configuration['dse'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self._func_table = OrderedDict()
# Internal state. May be used to store information about previous runs,
# autotuning reports, etc
self._state = {}
# Expression lowering: indexification, substitution rules, specialization
expressions = [indexify(i) for i in expressions]
expressions = self._apply_substitutions(expressions, subs)
expressions = self._specialize_exprs(expressions)
# Expression analysis
self.input = filter_sorted(flatten(e.reads for e in expressions))
self.output = filter_sorted(flatten(e.writes for e in expressions))
self.dimensions = filter_sorted(
flatten(e.dimensions for e in expressions))
# Group expressions based on their iteration space and data dependences,
# and apply the Devito Symbolic Engine (DSE) for flop optimization
clusters = clusterize(expressions)
clusters = rewrite(clusters, mode=set_dse_mode(dse))
self._dtype, self._dspace = clusters.meta
# Lower Clusters to a Schedule tree
stree = st_build(clusters)
# Lower Schedule tree to an Iteration/Expression tree (IET)
iet = iet_build(stree)
iet, self._profiler = self._profile_sections(iet)
iet = self._specialize_iet(iet, **kwargs)
iet = iet_insert_C_decls(iet)
iet = self._build_casts(iet)
# Derive parameters as symbols not defined in the kernel itself
parameters = self._build_parameters(iet)
# Finish instantiation
super(Operator, self).__init__(self.name, iet, 'int', parameters, ())
def _lower_iet(cls, stree, profiler, **kwargs):
"""
Iteration/Expression tree lowering:
* Turn a ScheduleTree into an Iteration/Expression tree;
* Introduce distributed-memory, shared-memory, and SIMD parallelism;
* Introduce optimizations for data locality;
* Finalize (e.g., symbol definitions, array casts)
"""
name = kwargs.get("name", "Kernel")
sregistry = kwargs['sregistry']
# Build an IET from a ScheduleTree
iet = iet_build(stree)
# Analyze the IET Sections for C-level profiling
profiler.analyze(iet)
# Wrap the IET with an EntryFunction (a special Callable representing
# the entry point of the generated library)
parameters = derive_parameters(iet, True)
iet = EntryFunction(name, iet, 'int', parameters, ())
# Lower IET to a target-specific IET
graph = Graph(iet)
graph = cls._specialize_iet(graph, **kwargs)
# Instrument the IET for C-level profiling
# Note: this is postponed until after _specialize_iet because during
# specialization further Sections may be introduced
instrument(graph, profiler=profiler, sregistry=sregistry)
return graph.root, graph
def _lower_iet(cls, stree, profiler, **kwargs):
"""
Iteration/Expression tree lowering:
* Turn a ScheduleTree into an Iteration/Expression tree;
* Perform analysis to detect optimization opportunities;
* Introduce distributed-memory, shared-memory, and SIMD parallelism;
* Introduce optimizations for data locality;
* Finalize (e.g., symbol definitions, array casts)
"""
name = kwargs.get("name", "Kernel")
iet = iet_build(stree)
# Instrument the IET for C-level profiling
iet = profiler.instrument(iet)
# Wrap the IET with a Callable
parameters = derive_parameters(iet, True)
iet = Callable(name, iet, 'int', parameters, ())
# Lower IET to a target-specific IET
graph = Graph(iet)
graph = cls._specialize_iet(graph, **kwargs)
return graph.root, graph
def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, sympy.Eq) for i in expressions):
raise InvalidOperator("Only SymPy expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
time_axis = kwargs.get("time_axis", Forward)
dse = kwargs.get("dse", configuration['dse'])
dle = kwargs.get("dle", configuration['dle'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self.func_table = OrderedDict()
# Expression lowering and analysis
expressions = [LoweredEq(e, subs=subs) for e in expressions]
self.dtype = retrieve_dtype(expressions)
self.input, self.output, self.dimensions = retrieve_symbols(
expressions)
# Set the direction of time acoording to the given TimeAxis
for time in [d for d in self.dimensions if d.is_Time]:
if not time.is_Stepping:
time.reverse = time_axis == Backward
# Parameters of the Operator (Dimensions necessary for data casts)
parameters = self.input + self.dimensions
# Group expressions based on their iteration space and data dependences,
# and apply the Devito Symbolic Engine (DSE) for flop optimization
clusters = clusterize(expressions)
clusters = rewrite(clusters, mode=set_dse_mode(dse))
# Lower Clusters to an Iteration/Expression tree (IET)
nodes = iet_build(clusters, self.dtype)
# Introduce C-level profiling infrastructure
nodes, self.profiler = self._profile_sections(nodes, parameters)
# Translate into backend-specific representation (e.g., GPU, Yask)
nodes = self._specialize(nodes, parameters)
# Apply the Devito Loop Engine (DLE) for loop optimization
dle_state = transform(nodes, *set_dle_mode(dle))
# Update the Operator state based on the DLE
self.dle_arguments = dle_state.arguments
self.dle_flags = dle_state.flags
self.func_table.update(
OrderedDict([(i.name, MetaCall(i, True))
for i in dle_state.elemental_functions]))
parameters.extend([i.argument for i in self.dle_arguments])
self.dimensions.extend([
i.argument for i in self.dle_arguments
if isinstance(i.argument, Dimension)
])
self._includes.extend(list(dle_state.includes))
# Introduce the required symbol declarations
nodes = iet_insert_C_decls(dle_state.nodes, self.func_table)
# Initialise ArgumentEngine
self.argument_engine = ArgumentEngine(clusters.ispace, parameters,
self.dle_arguments)
parameters = self.argument_engine.arguments
# Finish instantiation
super(Operator, self).__init__(self.name, nodes, 'int', parameters, ())
def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, Eq) for i in expressions):
raise InvalidOperator("Only `devito.Eq` expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
dse = kwargs.get("dse", configuration['dse'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self._func_table = OrderedDict()
# Internal state. May be used to store information about previous runs,
# autotuning reports, etc
self._state = self._initialize_state(**kwargs)
# Form and gather any required implicit expressions
expressions = self._add_implicit(expressions)
# Expression lowering: evaluation of derivatives, indexification,
# substitution rules, specialization
expressions = [i.evaluate for i in expressions]
expressions = [indexify(i) for i in expressions]
expressions = self._apply_substitutions(expressions, subs)
expressions = self._specialize_exprs(expressions)
# Expression analysis
self._input = filter_sorted(
flatten(e.reads + e.writes for e in expressions))
self._output = filter_sorted(flatten(e.writes for e in expressions))
self._dimensions = filter_sorted(
flatten(e.dimensions for e in expressions))
# Group expressions based on their iteration space and data dependences
# Several optimizations are applied (fusion, lifting, flop reduction via DSE, ...)
clusters = clusterize(expressions, dse_mode=set_dse_mode(dse))
self._dtype, self._dspace = clusters.meta
# Lower Clusters to a Schedule tree
stree = st_build(clusters)
# Lower Schedule tree to an Iteration/Expression tree (IET)
iet = iet_build(stree)
iet, self._profiler = self._profile_sections(iet)
iet = self._specialize_iet(iet, **kwargs)
# Derive all Operator parameters based on the IET
parameters = derive_parameters(iet, True)
# Finalization: introduce declarations, type casts, etc
iet = self._finalize(iet, parameters)
super(Operator, self).__init__(self.name, iet, 'int', parameters, ())
def _build(cls, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, Eq) for i in expressions):
raise InvalidOperator("Only `devito.Eq` expressions are allowed.")
name = kwargs.get("name", "Kernel")
dse = kwargs.get("dse", configuration['dse'])
# Python-level (i.e., compile time) and C-level (i.e., run time) performance
profiler = create_profile('timers')
# Lower input expressions to internal expressions (e.g., attaching metadata)
expressions = cls._lower_exprs(expressions, **kwargs)
# Group expressions based on their iteration space and data dependences
# Several optimizations are applied (fusion, lifting, flop reduction via DSE, ...)
clusters = clusterize(expressions, dse_mode=set_dse_mode(dse))
# Lower Clusters to a Schedule tree
stree = st_build(clusters)
# Lower Schedule tree to an Iteration/Expression tree (IET)
iet = iet_build(stree)
# Instrument the IET for C-level profiling
iet = profiler.instrument(iet)
# Wrap the IET with a Callable
parameters = derive_parameters(iet, True)
op = Callable(name, iet, 'int', parameters, ())
# Lower IET to a Target-specific IET
op, target_state = cls._specialize_iet(op, **kwargs)
# Make it an actual Operator
op = Callable.__new__(cls, **op.args)
Callable.__init__(op, **op.args)
# Header files, etc.
op._headers = list(cls._default_headers)
op._headers.extend(target_state.headers)
op._globals = list(cls._default_globals)
op._includes = list(cls._default_includes)
op._includes.extend(profiler._default_includes)
op._includes.extend(target_state.includes)
# Required for the jit-compilation
op._compiler = configuration['compiler']
op._lib = None
op._cfunction = None
# References to local or external routines
op._func_table = OrderedDict()
op._func_table.update(
OrderedDict([(i, MetaCall(None, False))
for i in profiler._ext_calls]))
op._func_table.update(
OrderedDict([(i.root.name, i) for i in target_state.funcs]))
# Internal state. May be used to store information about previous runs,
# autotuning reports, etc
op._state = cls._initialize_state(**kwargs)
# Produced by the various compilation passes
op._input = filter_sorted(
flatten(e.reads + e.writes for e in expressions))
op._output = filter_sorted(flatten(e.writes for e in expressions))
op._dimensions = filter_sorted(
flatten(e.dimensions for e in expressions))
op._dimensions.extend(target_state.dimensions)
op._dtype, op._dspace = clusters.meta
op._profiler = profiler
return op
def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, sympy.Eq) for i in expressions):
raise InvalidOperator("Only SymPy expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
dse = kwargs.get("dse", configuration['dse'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self.func_table = OrderedDict()
# Expression lowering: indexification, substitution rules, specialization
expressions = [indexify(i) for i in expressions]
expressions = [i.xreplace(subs) for i in expressions]
expressions = self._specialize_exprs(expressions)
# Expression analysis
self.input = filter_sorted(flatten(e.reads for e in expressions))
self.output = filter_sorted(flatten(e.writes for e in expressions))
self.dimensions = filter_sorted(flatten(e.dimensions for e in expressions))
# Group expressions based on their iteration space and data dependences,
# and apply the Devito Symbolic Engine (DSE) for flop optimization
clusters = clusterize(expressions)
clusters = rewrite(clusters, mode=set_dse_mode(dse))
self._dtype, self._dspace = clusters.meta
# Lower Clusters to a Schedule tree
stree = schedule(clusters)
stree = section(stree)
# Lower Sections to an Iteration/Expression tree (IET)
iet = iet_build(stree)
# Insert code for C-level performance profiling
iet, self.profiler = self._profile_sections(iet)
# Translate into backend-specific representation
iet = self._specialize_iet(iet, **kwargs)
# Insert the required symbol declarations
iet = iet_insert_C_decls(iet, self.func_table)
# Insert data and pointer casts for array parameters and profiling structs
iet = self._build_casts(iet)
# Derive parameters as symbols not defined in the kernel itself
parameters = self._build_parameters(iet)
# Finish instantiation
super(Operator, self).__init__(self.name, iet, 'int', parameters, ())
def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, sympy.Eq) for i in expressions):
raise InvalidOperator("Only SymPy expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
dse = kwargs.get("dse", configuration['dse'])
dle = kwargs.get("dle", configuration['dle'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self.func_table = OrderedDict()
# Expression lowering: indexification, substitution rules, specialization
expressions = [indexify(i) for i in expressions]
expressions = [i.xreplace(subs) for i in expressions]
expressions = self._specialize_exprs(expressions)
# Expression analysis
self.input = filter_sorted(flatten(e.reads for e in expressions))
self.output = filter_sorted(flatten(e.writes for e in expressions))
self.dimensions = filter_sorted(flatten(e.dimensions for e in expressions))
# Group expressions based on their iteration space and data dependences,
# and apply the Devito Symbolic Engine (DSE) for flop optimization
clusters = clusterize(expressions)
clusters = rewrite(clusters, mode=set_dse_mode(dse))
self._dtype, self._dspace = clusters.meta
# Lower Clusters to an Iteration/Expression tree (IET)
nodes = iet_build(clusters)
# Introduce C-level profiling infrastructure
nodes, self.profiler = self._profile_sections(nodes)
# Translate into backend-specific representation (e.g., GPU, Yask)
nodes = self._specialize_iet(nodes)
# Apply the Devito Loop Engine (DLE) for loop optimization
dle_state = transform(nodes, *set_dle_mode(dle))
# Update the Operator state based on the DLE
self.dle_args = dle_state.arguments
self.dle_flags = dle_state.flags
self.func_table.update(OrderedDict([(i.name, MetaCall(i, True))
for i in dle_state.elemental_functions]))
self.dimensions.extend([i.argument for i in self.dle_args
if isinstance(i.argument, Dimension)])
self._includes.extend(list(dle_state.includes))
# Introduce the required symbol declarations
nodes = iet_insert_C_decls(dle_state.nodes, self.func_table)
# Insert data and pointer casts for array parameters and profiling structs
nodes = self._build_casts(nodes)
# Derive parameters as symbols not defined in the kernel itself
parameters = self._build_parameters(nodes)
# Finish instantiation
super(Operator, self).__init__(self.name, nodes, 'int', parameters, ())
def __init__(self, expressions, **kwargs):
expressions = as_tuple(expressions)
# Input check
if any(not isinstance(i, Eq) for i in expressions):
raise InvalidOperator("Only `devito.Eq` expressions are allowed.")
self.name = kwargs.get("name", "Kernel")
subs = kwargs.get("subs", {})
dse = kwargs.get("dse", configuration['dse'])
# Header files, etc.
self._headers = list(self._default_headers)
self._includes = list(self._default_includes)
self._globals = list(self._default_globals)
# Required for compilation
self._compiler = configuration['compiler']
self._lib = None
self._cfunction = None
# References to local or external routines
self._func_table = OrderedDict()
# Internal state. May be used to store information about previous runs,
# autotuning reports, etc
self._state = {}
# Form and gather any required implicit expressions
expressions = self._add_implicit(expressions)
# Expression lowering: indexification, substitution rules, specialization
expressions = [indexify(i) for i in expressions]
expressions = self._apply_substitutions(expressions, subs)
expressions = self._specialize_exprs(expressions)
# Expression analysis
self._input = filter_sorted(flatten(e.reads + e.writes for e in expressions))
self._output = filter_sorted(flatten(e.writes for e in expressions))
self._dimensions = filter_sorted(flatten(e.dimensions for e in expressions))
# Group expressions based on their iteration space and data dependences,
# and apply the Devito Symbolic Engine (DSE) for flop optimization
clusters = clusterize(expressions)
clusters = rewrite(clusters, mode=set_dse_mode(dse))
self._dtype, self._dspace = clusters.meta
# Lower Clusters to a Schedule tree
stree = st_build(clusters)
# Lower Schedule tree to an Iteration/Expression tree (IET)
iet = iet_build(stree)
iet, self._profiler = self._profile_sections(iet)
iet = self._specialize_iet(iet, **kwargs)
# Derive all Operator parameters based on the IET
parameters = derive_parameters(iet, True)
# Finalization: introduce declarations, type casts, etc
iet = self._finalize(iet, parameters)
super(Operator, self).__init__(self.name, iet, 'int', parameters, ())
