def _specialize_iet(self, iet, **kwargs):
mapper = {}
self._includes.append('ops_seq.h')
ops_init = Call("ops_init", [0, 0, 2])
ops_timing = Call("ops_timing_output", [FunctionPointer("stdout")])
ops_exit = Call("ops_exit")
global_declarations = []
dims = None
for n, (section, trees) in enumerate(find_affine_trees(iet).items()):
callable_kernel, declarations, par_loop_call_block, dims = opsit(
trees, n)
global_declarations.extend(declarations)
self._header_functions.append(callable_kernel)
mapper[trees[0].root] = par_loop_call_block
mapper.update({i.root: mapper.get(i.root)
for i in trees}) # Drop trees
self._headers.append('#define OPS_%sD' % dims)
warning("The OPS backend is still work-in-progress")
global_declarations.append(Transformer(mapper).visit(iet))
return List(
body=[ops_init, *global_declarations, ops_timing, ops_exit])
def _specialize_iet(self, iet, **kwargs):
warning("The OPS backend is still work-in-progress")
ops_init = Call(namespace['ops_init'], [0, 0, 2])
ops_partition = Call(namespace['ops_partition'], Literal('""'))
ops_exit = Call(namespace['ops_exit'])
ops_block = OpsBlock('block')
# Extract all symbols that need to be converted to ops_dat
dims = []
to_dat = set()
for section, trees in find_affine_trees(iet).items():
dims.append(len(trees[0].dimensions))
symbols = set(FindSymbols('symbolics').visit(trees[0].root))
symbols -= set(FindSymbols('defines').visit(trees[0].root))
to_dat |= symbols
# To ensure deterministic code generation we order the datasets to
# be generated (since a set is an unordered collection)
to_dat = filter_sorted(to_dat)
name_to_ops_dat = {}
pre_time_loop = []
for f in to_dat:
if f.is_Constant:
continue
pre_time_loop.extend(create_ops_dat(f, name_to_ops_dat, ops_block))
for n, (section, trees) in enumerate(find_affine_trees(iet).items()):
pre_loop, ops_kernel = opsit(trees, n)
pre_time_loop.extend(pre_loop)
self._ops_kernels.append(ops_kernel)
assert (d == dims[0] for d in dims), \
"The OPS backend currently assumes that all kernels \
have the same number of dimensions"
ops_block_init = Expression(
ClusterizedEq(
Eq(ops_block,
namespace['ops_decl_block'](dims[0], Literal('"block"')))))
self._headers.append(namespace['ops_define_dimension'](dims[0]))
self._includes.append('stdio.h')
body = [
ops_init, ops_block_init, *pre_time_loop, ops_partition, iet,
ops_exit
]
return List(body=body)
def _specialize_iet(self, iet, **kwargs):
warning("The OPS backend is still work-in-progress")
affine_trees = find_affine_trees(iet).items()
# If there is no affine trees, then there is no loop to be optimized using OPS.
if not affine_trees:
return iet
ops_init = Call(namespace['ops_init'], [0, 0, 2])
ops_partition = Call(namespace['ops_partition'], Literal('""'))
ops_exit = Call(namespace['ops_exit'])
# Extract all symbols that need to be converted to ops_dat
dims = []
to_dat = set()
for _, tree in affine_trees:
dims.append(len(tree[0].dimensions))
symbols = set(FindSymbols('symbolics').visit(tree[0].root))
symbols -= set(FindSymbols('defines').visit(tree[0].root))
to_dat |= symbols
# Create the OPS block for this problem
ops_block = OpsBlock('block')
ops_block_init = Expression(
ClusterizedEq(
Eq(ops_block,
namespace['ops_decl_block'](dims[0], Literal('"block"')))))
# To ensure deterministic code generation we order the datasets to
# be generated (since a set is an unordered collection)
to_dat = filter_sorted(to_dat)
name_to_ops_dat = {}
pre_time_loop = []
after_time_loop = []
for f in to_dat:
if f.is_Constant:
continue
pre_time_loop.extend(
list(create_ops_dat(f, name_to_ops_dat, ops_block)))
# To return the result to Devito, it is necessary to copy the data
# from the dat object back to the CPU memory.
after_time_loop.extend(
create_ops_fetch(f, name_to_ops_dat,
self.time_dimension.extreme_max))
# Generate ops kernels for each offloadable iteration tree
mapper = {}
for n, (_, tree) in enumerate(affine_trees):
pre_loop, ops_kernel, ops_par_loop_call = opsit(
tree, n, name_to_ops_dat, ops_block, dims[0])
pre_time_loop.extend(pre_loop)
self._func_table[namespace['ops_kernel_file'](ops_kernel.name)] = \
MetaCall(ops_kernel, False)
mapper[tree[0].root] = ops_par_loop_call
mapper.update({i.root: mapper.get(i.root)
for i in tree}) # Drop trees
iet = Transformer(mapper).visit(iet)
assert (d == dims[0] for d in dims), \
"The OPS backend currently assumes that all kernels \
have the same number of dimensions"
self._headers.append(namespace['ops_define_dimension'](dims[0]))
self._includes.extend(['stdio.h', 'ops_seq.h'])
body = [
ops_init, ops_block_init, *pre_time_loop, ops_partition, iet,
*after_time_loop, ops_exit
]
return List(body=body)
def make_ops_kernels(iet):
warning("The OPS backend is still work-in-progress")
affine_trees = find_affine_trees(iet).items()
# If there is no affine trees, then there is no loop to be optimized using OPS.
if not affine_trees:
return iet, {}
ops_init = Call(namespace['ops_init'], [0, 0, 2])
ops_partition = Call(namespace['ops_partition'], Literal('""'))
ops_exit = Call(namespace['ops_exit'])
# Extract all symbols that need to be converted to ops_dat
dims = []
to_dat = set()
for _, tree in affine_trees:
dims.append(len(tree[0].dimensions))
symbols = set(FindSymbols('symbolics').visit(tree[0].root))
symbols -= set(FindSymbols('defines').visit(tree[0].root))
to_dat |= symbols
# Create the OPS block for this problem
ops_block = OpsBlock('block')
ops_block_init = Expression(
ClusterizedEq(
Eq(ops_block, namespace['ops_decl_block'](dims[0],
Literal('"block"')))))
# To ensure deterministic code generation we order the datasets to
# be generated (since a set is an unordered collection)
to_dat = filter_sorted(to_dat)
name_to_ops_dat = {}
pre_time_loop = []
after_time_loop = []
for f in to_dat:
if f.is_Constant:
continue
pre_time_loop.extend(
list(create_ops_dat(f, name_to_ops_dat, ops_block)))
# Copy data from device to host
after_time_loop.extend(
create_ops_fetch(f, name_to_ops_dat, f.grid.time_dim.extreme_max))
# Generate ops kernels for each offloadable iteration tree
mapper = {}
ffuncs = []
for n, (_, tree) in enumerate(affine_trees):
pre_loop, ops_kernel, ops_par_loop_call = opsit(
tree, n, name_to_ops_dat, ops_block, dims[0])
pre_time_loop.extend(pre_loop)
ffuncs.append(ops_kernel)
mapper[tree[0].root] = ops_par_loop_call
mapper.update({i.root: mapper.get(i.root) for i in tree}) # Drop trees
iet = Transformer(mapper).visit(iet)
assert (d == dims[0] for d in dims), \
"The OPS backend currently assumes that all kernels \
have the same number of dimensions"
iet = iet._rebuild(body=flatten([
ops_init, ops_block_init, pre_time_loop, ops_partition, iet.body,
after_time_loop, ops_exit
]))
return iet, {
'includes': ['stdio.h', 'ops_seq.h'],
'ffuncs': ffuncs,
'headers': [namespace['ops_define_dimension'](dims[0])]
}