U hd\0@sddlmZddlmZmZmZmZmZmZddl m Z m Z m Z m Z mZmZddlmZddlmZmZmZmZddlmZmZddlmZmZmZddlmZdd l m!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-d&d'Z.Gd(d)d)e/Z0dS)-)ConcreteTemplate)typestypingfuncdescconfigcompilersigutils)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)xr L/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/numba/cuda/compiler.py_nvvm_options_typesr"c@s(eZdZeedddZeedddZdS) CUDAFlagsNz NVVM options)typedefaultdoczCompute Capability)__name__ __module__ __qualname__r r" nvvm_optionstuplecompute_capabilityr r r r!r#sr#c@seZdZeddZdS)CUDACompileResultcCst|Sr)idselfr r r! entry_point7szCUDACompileResult.entry_pointN)r'r(r)propertyr1r r r r!r-6sr-cKst|}tf|Sr)r r-)entriesr r r!cuda_compile_result<sr4TF)Z mutates_CFGZ analysis_onlyc@s eZdZdZddZddZdS) CUDABackendZ cuda_backendcCst|dSrr__init__r/r r r!r7FszCUDABackend.__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_typeargsr4 typingctx targetctxstatusZ fail_reasonr;r<r=r?r8)r0stateZloweredr>r r r!run_passIs zCUDABackend.run_passNr'r(r)_namer7rFr r r r!r5Asr5c@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|dSrr6r/r r r!r7gszCreateLibrary.__init__cCs8|j}|jj}|jj}|j||d|_|jdS)N)r*T) rCcodegenZfunc_idZ func_qualnameflagsr*rJr<Zenable_object_caching)r0rErKnamer*r r r!rFjs   zCreateLibrary.run_passN)r'r(r)__doc__rHr7rFr r r r!rI]srIc@s eZdZdZddZddZdS)CUDALegalizationZcuda_legalizationcCst|dSr)rr7r/r r r!r7zszCUDALegalization.__init__csXddlm}|jrdS|j}fdd|D]\}t|tjr4|jq4dS)Nr)NVVMFcsTt|tjtjfr&d}t|n*t|tjrP|jD]}|djq.check_dtype) Znumba.cuda.cudadrv.nvvmrPZ is_nvvm70typemaprSrrZArrayrT)r0rErPZtypmapvr rVr!rF}s    zCUDALegalization.run_passNrGr r r r!rOusrOc@seZdZddZddZdS) CUDACompilercCstt}td}||j}|j|j||j}|j|j|td| |j}|j|j| |gS)NcudazCUDA legalization) r rZdefine_untyped_pipelinerEZpassesextendZdefine_typed_pipelineadd_passrOdefine_cuda_lowering_pipelinefinalize)r0ZdpbpmZuntyped_passesZ typed_passesZlowering_passesr r r!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^rrrIrr5r`)r0rErar r r!r_s    z*CUDACompiler.define_cuda_lowering_pipelineN)r'r(r)rbr_r r r r!r[sr[Nc  Cs|dkrtdddlm} | j} | j} t} d| _d| _d| _|sH|rNd| _ |rXd| _ |rdd| _ nd| _ |rtd| _ |r~d| _ |r|| _|| _ddlm} | d  tj| | |||| itd }W5QRX|j}||S) Nz#Compute Capability must be suppliedrQ cuda_targetTpythonnumpyr)target_overrider\)rBrCfuncrAr@rLlocalsZpipeline_class) ValueError descriptorrdr9r:r#Z no_compileZno_cpython_wrapperZno_cfunc_wrapperZ debuginfoZdbg_directives_onlyZ error_modelZ forceinlinefastmathr*r,Znumba.core.target_extensionrgrZ compile_extrar[r<r`)pyfuncr@rAdebuglineinfoinlinerlr*ccrdrBrCrLrgcresr<r r r! compile_cudasJ    rsc Cs|r|rd}tt|||r"dndd} t|\} } |p@tj}t|| | |||| |d} | jj} | r||s|| t j kr|t d|r| j }n6| j }|j}|j}|j}|| j | 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 sig: The signature representing the function's input and output types. :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, 0)``. :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)rlopt)rnrorlr*rqz'CUDA kernel must have void return type.)rq)rrrZnormalize_signaturerZCUDA_DEFAULT_PTX_CCrsr>r@rvoid TypeErrorr<r:__code__ co_filenameco_firstlinenoZprepare_cuda_kernelr?Z get_asm_str)rmsigrnrodevicerlrqrurUr*rAr@rrZrestylibZtgtcodefilenameZlinenumZkernelZptxr r r! compile_ptxs>     rc 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)rnror|rlrqru)rr,r)rmr{rnror|rlrurqr r r!compile_ptx_for_current_device9s rcCst|||jSr) declare_device_function_templatekeyrMrestypeargtypesr r r!declare_device_functionCsrcstddlm}|j}|j}tj|f|t|Gfdddt}tj |||d}| || ||S)NrQrccseZdZZgZdS)zBdeclare_device_function_template..device_function_templateN)r'r(r)rZcasesr Zextfnr{r r!device_function_templateNsrr) rkrdr9r:rr>ExternFunctionrrZExternalFunctionDescriptorZinsert_user_function)rMrrrdrBrCrr?r rr!rGs    rc@seZdZddZdS)rcCs||_||_dSr)rMr{)r0rMr{r r r!r7[szExternFunction.__init__N)r'r(r)r7r r r r!rZsr)FFFFNN)FFFFNT)FFFFT)1Znumba.core.typing.templatesrZ numba.corerrrrrrZnumba.core.compilerr r r r r rZnumba.core.compiler_lockrZnumba.core.compiler_machineryrrrrZnumba.core.errorsrrZnumba.core.typed_passesrrrwarningsrZnumba.cuda.apirr"r#r-r4r5rIrOr[rsrrrrobjectrr r r r!sP          "" : C