U ,d=-@s~ddlmZddlmZmZmZmZmZddlm Z m Z m Z m Z m Z mZddlmZddlmZmZmZmZddlmZmZddlmZmZmZddlmZdd lm Z d d Z!Gd d d e Z"GdddeZ#ddZ$edddGdddeZ%edddGdddeZ&edddGdddeZ'Gddde Z(ed(ddZ)ed)d d!Z*d*d"d#Z+d$d%Z,Gd&d'd'e-Z.dS)+)ConcreteTemplate)typestypingfuncdescconfigcompiler)sanitize_compile_result_entries CompilerBaseDefaultPassBuilderFlagsOption CompileResult)global_compiler_lock) LoweringPass AnalysisPass PassManager register_pass)NumbaInvalidConfigWarning TypingError)IRLegalizationNativeLowering AnnotateTypes)warn)get_current_devicecCs"|dkr dSt|tst|SdSN) isinstancedictAssertionError)xr7/tmp/pip-unpacked-wheel-eu7e0c37/numba/cuda/compiler.py_nvvm_options_typesr!c@seZdZeedddZdS) CUDAFlagsNz NVVM options)typedefaultdoc)__name__ __module__ __qualname__r r! nvvm_optionsrrrr r"s r"c@seZdZeddZdS)CUDACompileResultcCst|Sr)idselfrrr entry_point2szCUDACompileResult.entry_pointN)r&r'r(propertyr.rrrr r*1sr*cKst|}tf|Sr)rr*)entriesrrr cuda_compile_result7sr1TF)Z mutates_CFGZ analysis_onlyc@s eZdZdZddZddZdS) CUDABackendZ cuda_backendcCst|dSrr__init__r,rrr r4AszCUDABackend.__init__c CsJ|d}tj|jf|j}t|j|j|jj|j |j |j ||j d|_ dS)zH Back-end: Packages lowering output in a compile result cr)typing_contexttarget_contextZ typing_errortype_annotationlibrary call_helper signaturefndescT)rr; return_typeargsr1 typingctx targetctxstatusZ fail_reasonr8r9r:r<r5)r-stateZloweredr;rrr run_passDs zCUDABackend.run_passNr&r'r(_namer4rCrrrr r2<sr2c@s$eZdZdZdZddZddZdS) CreateLibraryz Create a CUDACodeLibrary for the NativeLowering pass to populate. The NativeLowering pass will create a code library if none exists, but we need to set it up with nvvm_options from the flags if they are present. create_librarycCst|dSrr3r,rrr r4bszCreateLibrary.__init__cCs8|j}|jj}|jj}|j||d|_|jdS)N)r)T) r@codegenZfunc_idZ func_qualnameflagsr)rGr9Zenable_object_caching)r-rBrHnamer)rrr rCes   zCreateLibrary.run_passN)r&r'r(__doc__rEr4rCrrrr rFXsrFc@s eZdZdZddZddZdS)CUDALegalizationZcuda_legalizationcCst|dSr)rr4r,rrr r4uszCUDALegalization.__init__csXddlm}|jrdS|j}fdd|D]\}t|tjr4|jq4dS)Nr)NVVMFcsTt|tjtjfr&d}t|n*t|tjrP|jD]}|djq.check_dtype) Znumba.cuda.cudadrv.nvvmrMZ is_nvvm70typemaprPrrArrayrQ)r-rBrMZtypmapvrrSr rCxs    zCUDALegalization.run_passNrDrrrr rLpsrLc@seZdZddZddZdS) CUDACompilercCstt}td}||j}|j|j||j}|j|j|td| |j}|j|j| |gS)NcudazCUDA legalization) r rZdefine_untyped_pipelinerBZpassesextendZdefine_typed_pipelineadd_passrLdefine_cuda_lowering_pipelinefinalize)r-ZdpbpmZuntyped_passesZ typed_passesZlowering_passesrrr define_pipeliness    zCUDACompiler.define_pipelinescCsPtd}|td|td|td|td|td||S)NZ cuda_loweringz$ensure IR is legal prior to loweringzannotate typeszcreate libraryznative loweringz cuda backend)rr\rrrFrr2r^)r-rBr_rrr r]s    z*CUDACompiler.define_cuda_lowering_pipelineN)r&r'r(r`r]rrrr rYsrYNc Csddlm}|j} |j} t} d| _d| _d| _|s8|rFd| _d| _ nd| _ |rVd| _ |r`d| _ |rj|| _ ddl m} | d tj| | |||| itd } W5QRX| j}|| S) NrN cuda_targetTpythonZnumpyr)target_overriderZ)r?r@funcr>r=rIlocalsZpipeline_class) descriptorrbr6r7r"Z no_compileZno_cpython_wrapperZno_cfunc_wrapperZ debuginfoZ error_modelZ forceinlinefastmathr)Znumba.core.target_extensionrdrZ compile_extrarYr9r^)pyfuncr=r>debuglineinfoinlinerhr)rbr?r@rIrdcresr9rrr compile_cudas>    rnc Cs|r|rd}tt|||||r&dndd} t|d||||| d} | jj} |rX| j} n6| j} | jj}t | jj }| | j| j || ||\} }|pt j}| j|d}|| fS)aCompile a Python function to PTX for a given set of argument types. :param pyfunc: The Python function to compile. :param args: A tuple of argument types to compile for. :param debug: Whether to include debug info in the generated PTX. :type debug: bool :param lineinfo: Whether to include a line mapping from the generated PTX to the source code. Usually this is used with optimized code (since debug mode would automatically include this), so we want debug info in the LLVM but only the line mapping in the final PTX. :type lineinfo: bool :param device: Whether to compile a device function. Defaults to ``False``, to compile global kernel functions. :type device: bool :param fastmath: Whether to enable fast math flags (ftz=1, prec_sqrt=0, prec_div=, and fma=1) :type fastmath: bool :param cc: Compute capability to compile for, as a tuple ``(MAJOR, MINOR)``. Defaults to ``(5, 3)``. :type cc: tuple :param opt: Enable optimizations. Defaults to ``True``. :type opt: bool :return: (ptx, resty): The PTX code and inferred return type :rtype: tuple z{debug=True with opt=True (the default) is not supported by CUDA. This may result in a crash - set debug=False or opt=False.r)rjrkrhoptN)rjrkrhr))cc)rrrnr;r=r9r7r8filenameintlinenumZprepare_cuda_kernelr<rZCUDA_DEFAULT_PTX_CCZ get_asm_str)rir>rjrkdevicerhrqrprRr)rmZrestylibZtgtrrrtkernelZptxrrr compile_ptxs4      rxc Cs tj}t|||||||ddS)zCompile a Python function to PTX for a given set of argument types for the current device's compute capabilility. This calls :func:`compile_ptx` with an appropriate ``cc`` value for the current device.T)rjrkrurhrqrp)rZcompute_capabilityrx)rir>rjrkrurhrprqrrr compile_ptx_for_current_devices rycstddlm}|j}|j}tj|f|t|Gfdddt}tj |||d}| || |S)NrNracseZdZZgZdS)z9declare_device_function..device_function_templateN)r&r'r(keyZcasesrZextfnsigrr device_function_template0sr})rJrestypeargtypes) rgrbr6r7rr;ExternFunctionrrZExternalFunctionDescriptorZinsert_user_function)rJr~rrbr?r@r}r<rr{r declare_device_function)s    rc@seZdZddZdS)rcCs||_||_dSr)rJr|)r-rJr|rrr r4<szExternFunction.__init__N)r&r'r(r4rrrr r;sr)FFFFN)FFFFNT)FFFFT)/Znumba.core.typing.templatesrZ numba.corerrrrrZnumba.core.compilerrr r r r r Znumba.core.compiler_lockrZnumba.core.compiler_machineryrrrrZnumba.core.errorsrrZnumba.core.typed_passesrrrwarningsrZnumba.cuda.apirr!r"r*r1r2rFrLrYrnrxryrobjectrrrrr sL         "" - ;