def _specialize_iet(cls, graph, **kwargs): options = kwargs['options'] sregistry = kwargs['sregistry'] passes = as_tuple(kwargs['mode']) # Fetch passes to be called passes_mapper = cls._make_iet_passes_mapper(**kwargs) # Call passes for i in passes: try: passes_mapper[i](graph) except KeyError: pass # Force-call `mpi` if requested via global option if 'mpi' not in passes and options['mpi']: passes_mapper['mpi'](graph) # Force-call `openmp` if requested via global option if 'openmp' not in passes and options['openmp']: passes_mapper['openmp'](graph) # Symbol definitions DataManager(sregistry).process(graph) return graph
def _specialize_iet(cls, graph, **kwargs): options = kwargs['options'] platform = kwargs['platform'] sregistry = kwargs['sregistry'] # 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) # Shared-memory parallelism ompizer.make_parallel(graph) # Misc optimizations hoist_prodders(graph) # Symbol definitions DataManager(sregistry).process(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'] passes = as_tuple(kwargs['mode']) # Create YASK kernels make_yask_kernels(graph, **kwargs) # Fetch passes to be called passes_mapper = cls._make_passes_mapper(**kwargs) # Call passes for i in passes: try: passes_mapper[i](graph) except KeyError: raise InvalidOperator("Unknown passes `%s`" % str(passes)) # Force-call `openmp` if requested via global option if 'openmp' not in passes and options['openmp']: passes_mapper['openmp'](graph) # Symbol definitions data_manager = DataManager() data_manager.place_definitions(graph) data_manager.place_casts(graph) 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): # Symbol definitions data_manager = DataManager() data_manager.place_definitions(graph) data_manager.place_casts(graph) return graph
def _specialize_iet(cls, graph, **kwargs): # Create OPS kernels make_ops_kernels(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'] sregistry = kwargs['sregistry'] # Distributed-memory parallelism if options['mpi']: mpiize(graph, mode=options['mpi']) # Shared-memory parallelism if options['openmp']: ompizer = Ompizer(sregistry, options) ompizer.make_parallel(graph) # Symbol definitions DataManager(sregistry).process(graph) return graph
def _specialize_iet(cls, graph, **kwargs): yk_solns = kwargs['yk_solns'] # Create YASK kernels make_yask_kernels(graph, yk_solns=yk_solns) # 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'] # Distributed-memory parallelism if options['mpi']: mpiize(graph, mode=options['mpi']) # Shared-memory parallelism if options['openmp']: ompizer = Ompizer() ompizer.make_parallel(graph) # Symbol definitions data_manager = DataManager() data_manager.place_definitions(graph) data_manager.place_casts(graph) return graph