def _specialize_iet(cls, graph, **kwargs):
options = kwargs['options']
platform = kwargs['platform']
sregistry = kwargs['sregistry']
# Flush denormal numbers
avoid_denormals(graph)
# Distributed-memory parallelism
optimize_halospots(graph)
if options['mpi']:
mpiize(graph, mode=options['mpi'])
# Lower IncrDimensions so that blocks of arbitrary shape may be used
relax_incr_dimensions(graph, sregistry=sregistry)
# Parallelism
parizer = cls._Target.Parizer(sregistry, options, platform)
parizer.make_simd(graph)
parizer.make_parallel(graph)
# Misc optimizations
hoist_prodders(graph)
# Symbol definitions
cls._Target.DataManager(sregistry).process(graph)
# Initialize the target-language runtime
parizer.initialize(graph)
return graph
def _specialize_iet(cls, graph, **kwargs):
options = kwargs['options']
platform = kwargs['platform']
# Flush denormal numbers
avoid_denormals(graph)
# Distributed-memory parallelism
optimize_halospots(graph)
if options['mpi']:
mpiize(graph, mode=options['mpi'])
# Lower IncrDimensions so that blocks of arbitrary shape may be used
relax_incr_dimensions(graph, counter=generator())
# SIMD-level parallelism
ompizer = Ompizer()
ompizer.make_simd(graph, simd_reg_size=platform.simd_reg_size)
# Shared-memory parallelism
ompizer.make_parallel(graph)
# Misc optimizations
hoist_prodders(graph)
# Symbol definitions
data_manager = DataManager()
data_manager.place_definitions(graph)
data_manager.place_casts(graph)
return graph
def _specialize_iet(cls, graph, **kwargs):
options = kwargs['options']
platform = kwargs['platform']
compiler = kwargs['compiler']
sregistry = kwargs['sregistry']
# Flush denormal numbers
avoid_denormals(graph, platform=platform)
# Distributed-memory parallelism
mpiize(graph, sregistry=sregistry, options=options)
# Lower BlockDimensions so that blocks of arbitrary shape may be used
relax_incr_dimensions(graph)
# Parallelism
parizer = cls._Target.Parizer(sregistry, options, platform, compiler)
parizer.make_simd(graph)
parizer.make_parallel(graph)
parizer.initialize(graph)
# Misc optimizations
hoist_prodders(graph)
# Symbol definitions
cls._Target.DataManager(sregistry).process(graph)
# Linearize n-dimensional Indexeds
linearize(graph, mode=options['linearize'], sregistry=sregistry)
return graph
def _specialize_iet(cls, graph, **kwargs):
"""
Transform the Iteration/Expression tree to offload the computation of
one or more loop nests onto YASK. This involves calling the YASK compiler
to generate YASK code. Such YASK code is then called from within the
transformed Iteration/Expression tree.
"""
options = kwargs['options']
yk_solns = kwargs['yk_solns']
# Flush denormal numbers
avoid_denormals(graph)
# Create YASK kernels
make_yask_kernels(graph, yk_solns=yk_solns)
# Shared-memory and SIMD-level parallelism
if options['openmp']:
YASKOmpizer().make_parallel(graph)
# Misc optimizations
loop_wrapping(graph)
# Symbol definitions
data_manager = DataManager()
data_manager.place_definitions(graph)
data_manager.place_casts(graph)
return graph
def _specialize_iet(cls, graph, **kwargs):
options = kwargs['options']
platform = kwargs['platform']
# Flush denormal numbers
avoid_denormals(graph)
# Distributed-memory parallelism
optimize_halospots(graph)
if options['mpi']:
mpiize(graph, mode=options['mpi'])
# Tiling
blocker = Blocker(options['blockinner'], options['blocklevels']
or cls.BLOCK_LEVELS)
blocker.make_blocking(graph)
# Shared-memory and SIMD-level parallelism
ompizer = Ompizer()
ompizer.make_simd(graph, simd_reg_size=platform.simd_reg_size)
if options['openmp']:
ompizer.make_parallel(graph)
# Misc optimizations
hoist_prodders(graph)
# Symbol definitions
data_manager = DataManager()
data_manager.place_definitions(graph)
data_manager.place_casts(graph)
return graph
def _specialize_iet(cls, graph, **kwargs):
options = kwargs['options']
platform = kwargs['platform']
sregistry = kwargs['sregistry']
# Flush denormal numbers
avoid_denormals(graph)
# Distributed-memory parallelism
optimize_halospots(graph)
if options['mpi']:
mpiize(graph, mode=options['mpi'])
# Lower IncrDimensions so that blocks of arbitrary shape may be used
relax_incr_dimensions(graph, sregistry=sregistry)
# SIMD-level parallelism
ompizer = Ompizer(sregistry, options)
ompizer.make_simd(graph, simd_reg_size=platform.simd_reg_size)
# Misc optimizations
hoist_prodders(graph)
# Symbol definitions
DataManager(sregistry).process(graph)
return graph
