iJddlZddlZddlmZmZmZddlZddlmZ dejfdZ dejfdZ dejfdZ deddfd Zdejfd Zdejfd Zdejfd Zdeefd Z d dededeedeedeededeeeffdZGddZGddZ d!deeefdeeedeeeedfffdZ d"dedededefdZy)#N)AnyOptionalUnion)_get_device_indexreturncjtjdk(r5tjdtj j dd}ntjd}|j|_|j|_ |j|_ |j|_|j|_|S)Nwin32 amdhip64_r.dllzlibamdhip64.so)sysplatformctypesCDLLtorchversionhiphipGetErrorStringcuGetErrorStringhipModuleLoadDatacuModuleLoadDatahipModuleGetFunctioncuModuleGetFunctionhipModuleLaunchKernelcuLaunchKernelhipFuncSetAttributecuFuncSetAttribute)libs K/var/www/html/engine/venv/lib/python3.12/site-packages/torch/cuda/_utils.py_get_hip_runtime_libraryr s ||wkkIemm&7&7&:%;4@Akk*+00C00C!66C22C 44C Jc|tjdk(rtjdStjdS)Nr z nvcuda.dllz libcuda.so.1)r r rrr r_get_cuda_libraryr#s, ||w{{<(({{>**r c^tjjr tSt SN)rrrrr#r"r r_get_gpu_runtime_libraryr& s! }}')) ""r resultc|dk(rytj}t}|j|tj||j |j j nd}td|)NrUnknown CUDA error CUDA error: )rc_char_pr&rbyrefvaluedecode RuntimeError)r'err_strlibcuda error_messages r _check_cudar3(sn {ooG&(G VV\\'%:;")--"; AU m_5 66r cttjdk(redjdtjj ddtjj dg}t jd|d}nt jd}|j|_ |j|_ |j|_ |j|_|j |_|j$|_|j(|_|j,|_|j0|_|j4|_|S) Nr 0rhiprtcr z libhiprtc.so)r r joinrrrrrhiprtcGetErrorStringnvrtcGetErrorStringhiprtcCreateProgramnvrtcCreateProgramhiprtcDestroyProgramnvrtcDestroyProgramhiprtcCompileProgramnvrtcCompileProgramhiprtcGetCodeSizenvrtcGetPTXSize hiprtcGetCode nvrtcGetPTXhiprtcGetProgramLogSizenvrtcGetProgramLogSizehiprtcGetProgramLognvrtcGetProgramLoghiprtcAddNameExpressionnvrtcAddNameExpressionhiprtcGetLoweredNamenvrtcGetLoweredName) version_strrs r_get_hiprtc_libraryrO4s ||wggsEMM$5$5a$8#u}}?P?PQR?STU kkF;-t45kk.)"66C 44C!66C!66C//C''CO!$!t|jjd k\sJd |g}|jd|r'|D]"}| j|jd$t!}| j#|Dcgc]}|jdc}t%| }t'j(|z| }t'j*}|j-t'j.|||djddd|jd}|j1||j3|||}|k7rt'j4}j7|t'j.|t'j8|j:}j=||t?d|j:jAt'j4}|jC|t'j.|t'j8|j:}|jE||t'j(}|jG||t'j.||j:|j:jA}nd}jIt'j.||jjr |jJn |j:}||fScc}w)a Compiles a CUDA kernel using NVRTC and returns the PTX code. Args: kernel_source (str): The CUDA kernel source code as a string kernel_name (str): The name of the kernel function to compile compute_capability (str, None): The compute capability to target (e.g., "86"). If None, will detect from current device. cuda_include_dirs (list, None): List of directories containing CUDA headers nvcc_options (list, None): Additional options to pass to NVRTC auto_pch (bool): Enable automatic precompiled headers (CUDA 12.8+) Returns: Tuple[bytes, str]: The compiled PTX code and mangled kernel name rNr'rc|k7rotj}j|tj||j|jj nd}t d|y)Nr)r*)rr+r;r,r-r.r/)r'r0r2 NVRTC_SUCCESSlibnvrtcs r check_nvrtcz#_nvrtc_compile..check_nvrtcso ] "oo'G  ( (g1F G==, $$&)  m_=> > #r utf-8z--offload-arch=z--gpu-architecture=sm_) include_pathsrTz-Iz12.8zPCH requires CUDA 12.8+z--pchz.cuzKernel compilation failed: r5)& torch.cudar\rSencoderTget_device_propertiescurrent_devicerr gcnArchNamemajorminorappendr`rrstrreralenrr+c_void_pr=r,rKrAc_size_trGcreate_string_bufferr-rIr/r.rCrErMr?raw) rfrgrhrirjrkrrp source_bytespropsoptionsrrcuda_include_paths cuda_path directoryoptionnvrtc_compatible_flagsrc num_options options_arrayprog c_kernel_namereslog_sizelogptx_sizeptxc_mangled_name mangled_name ptx_bytesrnros @@r_nvrtc_compiler}s0$%HM ?C ?D ?!''0L! 001J1J1LM ==  $)$5$5#6 $)KK= !> G }});(<=DDFG/0B/CDKKMN8&v.'2 I;'..012* 6I NNR {+224 5 65==%%&&0K2KK0  LG$" 3F NN6==1 2 3;< NN5KLTDKK(LMg,K__{2W=M ?? D## LL  m3  & & (      &&w/M//mDE  & &t[- HC m??$''fll8.DE))(..9##D#.9#)):J:J:L9MNOO H((v||H/EFG  % %hnn 5C$$T3/0__&N$$T=&,,~:VW'%++224     d!34 !==,,#))I l ""sMs'Rc@eZdZdejddfdZdeddfdZy) _CudaModulemodulerNc ||_i|_yr%)_module_kernels)selfrs r__init__z_CudaModule.__init__s 02 r name _CudaKernelc ||jvr|j|Sddlm}|}tj} t |j tj||j|jdt||j}||j|<|S#t$r}td|d|d}~wwxYw)Nr)r&rqzNo kernel named 'z' in this module) rtorch.cuda._utilsr&rr}r3rr,rrtrr/AttributeError)rrr&r1funckernelerrs r __getattr__z_CudaModule.__getattr__s 4== ==& & ?*,  V ++LL& dkk'6J  !t||4F"(DMM$ M V #4TF:J!KLRU U VsA.B// C 8CC )__name__ __module__ __qualname__rr}rr{rr"r rrrs/3v343VV Vr rc eZdZdZdej dej ddfdZ ddeeeefdeeeefd e e d ed e e ddf d Z d eddfdZ y)rzT Represents a compiled CUDA kernel that can be called with PyTorch tensors. rrrNc.||_||_d|_y)Nr)rr_max_shared_mem_bytes)rrrs rrz_CudaKernel.__init__3s  %&"r gridblockargs shared_memstreamcBddl}|jjj}|sg}g}g} |D]O} t | |j r| j s'| jr| js tdtj| j} |j| | jtj| t | tr:tj | } | jtj| t | t"r;tj$| } | jtj| ;t'dt)| tjt+| z}t-| D],\}} tj.| tj||<.|ddl}|jj3}|dk\rQ|j4dk(s||j4kDr3|j4dk(rdnd|j4d}t7d |d |d t9|j;|j<|d|d |d |d|d |d ||j>|d y)a Call the compiled CUDA kernel Args: grid (tuple): Grid dimensions (grid_x, grid_y, grid_z) block (tuple): Block dimensions (block_x, block_y, block_z) args (list): List of arguments to pass to the kernel. PyTorch tensor arguments will be automatically converted to pointers. shared_mem (int): Shared memory size in bytes stream (torch.cuda.Stream): CUDA stream to use. If None, uses current stream. rNz?All tensor arguments must be CUDA tensors or pinned CPU tensorszUnsupported argument type: znot configuredzonly z bytes configuredzKernel requires z' bytes of shared memory (>= 48KB), but ze. Call kernel.set_shared_memory_config(shared_mem) after compilation and before launching the kernel.r7) rrT_utilsr& isinstanceTensoris_cudais_cpu is_pinned ValueErrorrr}data_ptrrzr,rSc_intfloatc_double TypeErrortyper| enumeratecastrscurrent_streamrr/r3rr_as_parameter_)rrrrrrrr1processed_argsc_argsargptrrr c_args_arrayiconfigured_msgs r__call__z_CudaKernel.__call__8s_& **##<<>D13 KC#u||,{{CJJ3==?$Yooclln5%%c* fll3/0C% S) fll512C'!??3/ fll845"=d3i[ IJJ+ K0#f+58 ' @FAs$kk#v?LO @ > ZZ..0F  "  & &! +zD!!/ 01GG 783  & & ;   &6"r )rrrrNrN)rrr__doc__rr}rtuplerSrlistrrrr"r rrr.s'V__'foo'$'&/&/# $ _ CcM"_ S#s]#_ tn _  _  _  _ B(6(6(6r rr kernel_namesc 8ddl}t}t|tr|j d}t j }|jj}|5t|jt j||ddd|s t|Si}|D]c}t j }t|jt j|||j dt||||<e|S#1swYxYw)a, Loads a CUDA module from PTX code and returns a module object that can access kernels. Args: ptx (bytes or str): The PTX code to load kernel_names (list, optional): List of kernel names to extract from the module. If None, will return a module object with __getattr__. Returns: object: If kernel_names is None, returns a module object with __getattr__ to access kernels. If kernel_names is provided, returns a dict mapping kernel names to _CudaKernel objects. rNrq)rsr&rr{rtrr}rTrr3rr,rrr) rrrr1rrkernelsrrs r_cuda_load_modulers '(G#sjj!__ F ZZ & & (F IG,,V\\&-A3GHI 6""G2   ' ' T"FDKK,@  $D&1 2 N!IIs /DDdeviceoptional allow_cpuct|tr|St|trtj|}t|tjr;|r|j dvr+t d||j dk7rt d|tjjs0t|tjjr |jSt|||S)aGet the device index from :attr:`device`, which can be a torch.device object, a Python integer, or ``None``. If :attr:`device` is a torch.device object, returns the device index if it is a CUDA device. Note that for a CUDA device without a specified index, i.e., ``torch.device('cuda')``, this will return the current default CUDA device if :attr:`optional` is ``True``. If :attr:`allow_cpu` is ``True``, CPU devices will be accepted and ``-1`` will be returned in this case. If :attr:`device` is a Python integer, it is returned as is. If :attr:`device` is ``None``, this will return the current default CUDA device if :attr:`optional` is ``True``. )rTcpuz(Expected a cuda or cpu device, but got: rTz!Expected a cuda device, but got: ) rrSr{rrrrjit is_scriptingrTidx_torch_get_device_index)rrrs rrrs &# &#f%&%,,' {{/1 #KF8!TUU [[F "@IJ J 99 ! ! # fejj// 0::  "68Y ??r )NNNFr%)FF)rr typingrrrr torch._utilsrrrrr#r&rSr3rOrZr\rr{reboolrbytesrrrdictrr"r rrs '' F &++ +6;;+#&++# 7 7 7V[[*6FKK6&$fkk$tCy6)-(,#' P#P#P#! P# ~ P# 4. P#  P# 5#:P#fVV