def define_pipelines(self): dpb = DefaultPassBuilder pm = PassManager('cuda') untyped_passes = dpb.define_untyped_pipeline(self.state) pm.passes.extend(untyped_passes.passes) typed_passes = dpb.define_typed_pipeline(self.state) pm.passes.extend(typed_passes.passes) pm.add_pass(CUDALegalization, "CUDA legalization") lowering_passes = self.define_cuda_lowering_pipeline(self.state) pm.passes.extend(lowering_passes.passes) pm.finalize() return [pm]
def define_nopython_pipeline(state, name='nopython'): """Returns an nopython mode pipeline based PassManager """ # compose pipeline from untyped, typed and lowering parts dpb = DefaultPassBuilder pm = PassManager(name) untyped_passes = dpb.define_untyped_pipeline(state) pm.passes.extend(untyped_passes.passes) typed_passes = dpb.define_typed_pipeline(state) pm.passes.extend(typed_passes.passes) lowering_passes = dpb.define_nopython_lowering_pipeline(state) pm.passes.extend(lowering_passes.passes) pm.finalize() return pm
def compile_to_ir(self, func, DCE=False): """ Compile and return IR """ func_id = bytecode.FunctionIdentity.from_function(func) self.state.func_id = func_id ExtractByteCode().run_pass(self.state) state = self.state name = "DCE_testing" pm = PassManager(name) pm.add_pass(TranslateByteCode, "analyzing bytecode") pm.add_pass(FixupArgs, "fix up args") pm.add_pass(IRProcessing, "processing IR") pm.add_pass(NopythonTypeInference, "nopython frontend") if DCE is True: pm.add_pass(DeadCodeElimination, "DCE after typing") pm.finalize() pm.run(state) return state.func_ir
def define_typed_pipeline(state, name="typed"): """Returns the typed part of the nopython pipeline""" pm = PassManager(name) # typing pm.add_pass(NopythonTypeInference, "nopython frontend") # strip phis pm.add_pass(PreLowerStripPhis, "remove phis nodes") # optimisation pm.add_pass(InlineOverloads, "inline overloaded functions") if state.flags.auto_parallel.enabled: pm.add_pass(PreParforPass, "Preprocessing for parfors") if not state.flags.no_rewrites: pm.add_pass(NopythonRewrites, "nopython rewrites") if state.flags.auto_parallel.enabled: pm.add_pass(ParforPass, "convert to parfors") pm.finalize() return pm
def define_untyped_pipeline(state, name='untyped'): """Returns an untyped part of the nopython pipeline""" pm = PassManager(name) if state.func_ir is None: pm.add_pass(TranslateByteCode, "analyzing bytecode") pm.add_pass(FixupArgs, "fix up args") pm.add_pass(IRProcessing, "processing IR") pm.add_pass(WithLifting, "Handle with contexts") # inline closures early in case they are using nonlocal's # see issue #6585. pm.add_pass(InlineClosureLikes, "inline calls to locally defined closures") # pre typing if not state.flags.no_rewrites: pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") pm.add_pass(DeadBranchPrune, "dead branch pruning") pm.add_pass(GenericRewrites, "nopython rewrites") # convert any remaining closures into functions pm.add_pass(MakeFunctionToJitFunction, "convert make_function into JIT functions") # inline functions that have been determined as inlinable and rerun # branch pruning, this needs to be run after closures are inlined as # the IR repr of a closure masks call sites if an inlinable is called # inside a closure pm.add_pass(InlineInlinables, "inline inlinable functions") if not state.flags.no_rewrites: pm.add_pass(DeadBranchPrune, "dead branch pruning") pm.add_pass(FindLiterallyCalls, "find literally calls") pm.add_pass(LiteralUnroll, "handles literal_unroll") if state.flags.enable_ssa: pm.add_pass(ReconstructSSA, "ssa") pm.add_pass(LiteralPropagationSubPipelinePass, "Literal propagation") pm.finalize() return pm
def define_pipelines(self): name = 'test parfor aliasing' pm = PassManager(name) pm.add_pass(TranslateByteCode, "analyzing bytecode") pm.add_pass(FixupArgs, "fix up args") pm.add_pass(IRProcessing, "processing IR") pm.add_pass(WithLifting, "Handle with contexts") # pre typing if not self.state.flags.no_rewrites: pm.add_pass(GenericRewrites, "nopython rewrites") pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") pm.add_pass(DeadBranchPrune, "dead branch pruning") pm.add_pass(InlineClosureLikes, "inline calls to locally defined closures") # typing pm.add_pass(NopythonTypeInference, "nopython frontend") pm.add_pass(AnnotateTypes, "annotate types") # lower pm.add_pass(NoPythonBackend, "nopython mode backend") pm.finalize() return [pm]
def run_pass(self, state): # run as subpipeline from numba.core.compiler_machinery import PassManager pm = PassManager("subpipeline") pm.add_pass(PartialTypeInference, "performs partial type inference") pm.finalize() pm.run(state) mutated = False func_ir = state.func_ir for block in func_ir.blocks.values(): for assign in block.find_insts(ir.Assign): binop = assign.value if not (isinstance(binop, ir.Expr) and binop.op == 'binop'): continue if self.is_dtype_comparison(func_ir, binop): var = func_ir.get_assignee(binop) typ = state.typemap.get(var.name, None) if isinstance(typ, types.BooleanLiteral): loc = binop.loc rhs = ir.Const(typ.literal_value, loc) new_assign = ir.Assign(rhs, var, loc) # replace instruction block.insert_after(new_assign, assign) block.remove(assign) mutated = True if mutated: pm = PassManager("subpipeline") # rewrite consts / dead branch pruning pm.add_pass(DeadCodeElimination, "dead code elimination") pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") pm.add_pass(DeadBranchPrune, "dead branch pruning") pm.finalize() pm.run(state) return mutated
def define_nopython_pipeline(state, name="dppy_nopython"): """Returns an nopython mode pipeline based PassManager""" pm = PassManager(name) DPPYPassBuilder.default_numba_nopython_pipeline(state, pm) # Intel GPU/CPU specific optimizations pm.add_pass(DPPYPreParforPass, "Preprocessing for parfors") if not state.flags.no_rewrites: pm.add_pass(NopythonRewrites, "nopython rewrites") pm.add_pass(DPPYParforPass, "convert to parfors") # legalise pm.add_pass( NoPythonSupportedFeatureValidation, "ensure features that are in use are in a valid form", ) pm.add_pass(IRLegalization, "ensure IR is legal prior to lowering") # lower pm.add_pass(SpirvFriendlyLowering, "SPIRV-friendly lowering pass") pm.add_pass(DPPYNoPythonBackend, "nopython mode backend") pm.add_pass(DPPYDumpParforDiagnostics, "dump parfor diagnostics") pm.finalize() return pm