J/Ph>8ddlmZddlmZddlmZmZmZmZm Z m Z ddl m Z m Z mZmZmZmZddlmZddlmZmZmZddlmZddlmZmZmZdd lmZdd l m!Z!dd l"m#Z#d Z$Gd deZ%GddeZ&dZ'eddGddeZ(eddGddeZ)Gdde Z*e d)dZ+dZ,e d*d Z- d+d!Z. d,d#Z/ d-d$Z0d%Z1d&Z2Gd'd(e3Z4dS).)ir)ConcreteTemplate)typestypingfuncdescconfigcompilersigutils)sanitize_compile_result_entries CompilerBaseDefaultPassBuilderFlagsOption CompileResult)global_compiler_lock) LoweringPass PassManager register_pass)NumbaInvalidConfigWarning)IRLegalizationNativeLowering AnnotateTypes)warn)get_current_device)CUDACABICallConvc<|dSt|tsJ|SN) isinstancedict)xs S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/cuda/compiler.py_nvvm_options_typer"s)yt!T"""""cFeZdZeeddZeeddZdS) CUDAFlagsNz NVVM options)typedefaultdoczCompute Capability)__name__ __module__ __qualname__rr" nvvm_optionstuplecompute_capabilityr#r!r%r%sQ6  L    r#r%c$eZdZedZdS)CUDACompileResultc t|Sr)idselfs r! entry_pointzCUDACompileResult.entry_point9s $xxr#N)r)r*r+propertyr6r/r#r!r1r18s- Xr#r1c 8t|}tdi|S)Nr/)r r1)entriess r!cuda_compile_resultr:>s#-g66G  ' 'w ' ''r#TF) mutates_CFG analysis_onlyceZdZdZdZdZdS) CUDABackend cuda_backendc.tj|dSrr__init__r4s r!rBzCUDABackend.__init__Hd#####r#c |d}tj|jg|jR}t |j|j|jj|j |j |j ||j |_ dS)zH Back-end: Packages lowering output in a compile result cr)typing_contexttarget_context typing_errortype_annotationlibrary call_helper signaturefndescT)rrL return_typeargsr: typingctx targetctxstatus fail_reasonrIrJrKrMrE)r5stateloweredrLs r!run_passzCUDABackend.run_passKsr+$U%6DDDD & ? ?1!1M+>    tr#N)r)r*r+_namerBrVr/r#r!r>r>Cs9 E$$$r#r>c"eZdZdZdZdZdZdS) 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_libraryc.tj|dSrrAr4s r!rBzCreateLibrary.__init__irCr#c|j}|jj}|jj}||||_|jdS)N)r,T) rQcodegenfunc_id func_qualnameflagsr,rZrJenable_object_caching)r5rTr]namer,s r!rVzCreateLibrary.run_passls\/))++}*{/ ..t,.OO  ++---tr#N)r)r*r+__doc__rWrBrVr/r#r!rYrY_sC E$$$r#rYceZdZdZdZdS) CUDACompilerct}td}||j}|j|j||j}|j|j||j}|j|j||gS)Ncuda) r rdefine_untyped_pipelinerTpassesextenddefine_typed_pipelinedefine_cuda_lowering_pipelinefinalize)r5dpbpmuntyped_passes typed_passeslowering_passess r!define_pipelineszCUDACompiler.define_pipelinesxs   44TZ@@ .///00<<  ,---<rm)r5rTros r!rlz*CUDACompiler.define_cuda_lowering_pipelines  ) ) N: < < < M#3444 M#3444 N$5666 K000  r#N)r)r*r+rsrlr/r#r!rerews2     r#reNc |tdddlm} | j} | j} t } d| _d| _d| _|s|rd| _ |rd| _ |rd| _ nd| _ |rd| _ |rd| _ |r|| _|| _ddlm} | d 5t%j| | |||| it( }dddn #1swxYwY|j}||S) Nz#Compute Capability must be supplied cuda_targetTpythonnumpyr)target_overriderg)rPrQfuncrOrNr`localspipeline_class) ValueError descriptorrzrFrGr% no_compileno_cpython_wrapperno_cfunc_wrapper debuginfodbg_directives_only error_model forceinlinefastmathr,r.numba.core.target_extensionr}r compile_extrarerJrm)pyfuncrNrOdebuglineinfoinlinerr,ccrzrPrQr`r}cresrJs r! compile_cudars z>???''''''*I*I KKEE#E!E )$(! $$# ! *)!E<;;;;;  CC% 09+1+/2=,1-/5ACCCCCCCCCCCCCCCCCClG  Ks!"CCCc|j|jd||}|||j}|j}t |}|||} |j|j|} | d} tj | | |j } tj | | |} tj | d}||}||| j}|j|| |||\}}|||| ||S)z Wrap a Numba ABI function in a C ABI wrapper at the NVVM IR level. The C ABI wrapper will have the same name as the source Python function. _function_) entry_namer,zcuda.cabi.wrapper)r]rZrbadd_linking_libraryargtypesrestyperget_function_type call_conv create_modulerFunctionllvm_func_name IRBuilderappend_basic_blockget_arg_packerfrom_argumentsrO call_functionret add_ir_modulerm)contextlibrMwrapper_function_namer,rJrr c_call_convwrapfntyfntywrapper_moduler~wrapfnbuilderarginfocallargs_ return_values r!cabi_wrap_functionrsk((CH)@)@)@4I6B)DDG $$$HnG"7++K,,Wh??H   . .v~x H HD**+>??N ;~tV-B C CD [3H I IFl644R8899G$$X..G%%gv{;;H'55w(44OA| KK  .)))  Nr#cptxc b|dvrtd||dkr|std| dvrtd| |r |rd} tt| | dk} | p t} ||rd nd d } | rd | d <t j|\}}|p t j}t||||||| |}|j j }|r!|s|tj krtd|j}|rA|j}|dkr3| d|j}t%|||j|| }n=|j}|j}|j}||j|j||| ||\}}| r||}n||}||fS)aCompile a Python function to PTX or LTO-IR 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. If this is a tuple of argument types without a return type, the inferred return type is returned by this function. If a signature including a return type is passed, the compiled code will include a cast from the inferred return type to the specified return type, and this function will return the specified return type. :param debug: Whether to include debug info in the compiled code. :type debug: bool :param lineinfo: Whether to include a line mapping from the compiled code 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 IR but only the line mapping in the final output. :type lineinfo: bool :param device: Whether to compile a device function. :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 :param abi: The ABI for a compiled function - either ``"numba"`` or ``"c"``. Note that the Numba ABI is not considered stable. The C ABI is only supported for device functions at present. :type abi: str :param abi_info: A dict of ABI-specific options. The ``"c"`` ABI supports one option, ``"abi_name"``, for providing the wrapper function's name. The ``"numba"`` ABI has no options. :type abi_info: dict :param output: Type of output to generate, either ``"ptx"`` or ``"ltoir"``. :type output: str :return: (code, resty): The compiled code and inferred return type :rtype: tuple )numbarzUnsupported ABI: rz&The C ABI is not supported for kernels)rltoirzUnsupported output type: 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.rr)roptNzgen-lto)rrrr,rz'CUDA kernel must have void return type.abi_name)r)NotImplementedErrorrrrr normalize_signaturerCUDA_DEFAULT_PTX_CCrrLrNrvoid TypeErrorrGrJgetr)rrM__code__ co_filenameco_firstlinenoprepare_cuda_kernel get_ltoir get_asm_str)rsigrrdevicerrrabiabi_infooutputmsgltor,rOrNrrestytgtr wrapper_namecodefilenamelinenumkernels r!compilers1\ .  !";c";";<<< czz&z!"JKKK %%%!"Ff"F"FGGG --2 &s + +,,, W C!466HqqQL  '"& Y 4S99D+ )v)B  T!)H%1b : : :D N &E CVC 3 3ABBB  C 7l #::#<< FODDL$S#t{L%133C#%--dlDK.6 h.577 V &}}}##"%% ;r#c \tj} t||||||| ||||  S)zCompile a Python function to PTX or LTO-IR for a given signature for the current device's compute capabilility. This calls :func:`compile` with an appropriate ``cc`` value for the current device. rrrrrrrrr)rr.r) rrrrrrrrrrrs r!compile_for_current_devicerjsA    0B 63ehv$#$V 5 5 55r#rc 6t|||||||||| d S)zCompile a Python function to PTX for a given signature. See :func:`compile`. The defaults for this function are to compile a kernel with the Numba ABI, rather than :func:`compile`'s default of compiling a device function with the C ABI.rr)r) rrrrrrrrrrs r! compile_ptxrvs3 63ehv$#$U 4 4 44r#c Ztj} t||||||| ||| S)zCompile a Python function to PTX for a given signature for the current device's compute capabilility. See :func:`compile_ptx`.)rrrrrrrr)rr.r) rrrrrrrrrrs r!compile_ptx_for_current_devicers?    0B vs%($xBC 3 3 33r#c.t|||jSr) declare_device_function_templatekeyrbrrs r!declare_device_functionrs +D'8 D D HHr#c( ddlm}|j}|j}t j|g|R t | G fddt}tj |||}| || ||S)NrxryceZdZZgZdS)Bdeclare_device_function_template..device_function_templateN)r)r*r+rcases)extfnrsr!device_function_templatersr#rr) rrzrFrGrrLExternFunctionrrExternalFunctionDescriptorinsert_user_function) rbrrrzrPrQrrMrrs @@r!rrs''''''*I*I  7 .X . . .C 4 % %E#3 0 7X777F ""5*BCCC ""5&111 ##r#ceZdZdZdS)rc"||_||_dSr)rbr)r5rbrs r!rBzExternFunction.__init__s r#N)r)r*r+rBr/r#r!rrs#r#r)FFFFNN) FFTFNTrNr)FFTFTrNr)FFFFNTrN)FFFFTrN)5llvmliternumba.core.typing.templatesr numba.corerrrrr r numba.core.compilerr r r rrrnumba.core.compiler_lockrnumba.core.compiler_machineryrrrnumba.core.errorsrnumba.core.typed_passesrrrwarningsrnumba.cuda.apirnumba.cuda.targetrr"r%r1r:r>rYrerrrrrrrrobjectrr/r#r!rs888888JJJJJJJJJJJJJJJJ0000000000000000:99999GGGGGGGGGG7777774444444444------......        :  ((( 4u555,6565666L76.<BBG<@7777t)))X=AAEggggTCH@D>C 5 5 5 5BGIM4444GLEI9=3333III$$$&Vr#