9i1dSSKrSSKrSSKJrJrJr SSKrSSKJr S\R4Sjr S\ SS4Sjr S\R4SjrSS \S \S \\S \S \\S\\S\4Sjjr"SS5r"SS5rSS\\\4S\\\S\\\\S444SjjrSS\S\S\S\ 4Sjjrg)N)AnyOptionalUnion)_get_device_indexreturnc[RS:Xa[R"S5$[R"S5$)Nwin32z nvcuda.dllz libcuda.so.1)sysplatformctypesCDLLQ/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/torch/cuda/_utils.py_get_cuda_libraryr s, ||w{{<(({{>**rresultcUS:Xag[R"5n[5nURU[R"U55 UR bUR R 5OSn[SU35e)NrUnknown CUDA error CUDA error: )r c_char_prcuGetErrorStringbyrefvaluedecode RuntimeError)rerr_strlibcuda error_messages r _check_cudarsn {ooG!G VV\\'%:;")--"; AU m_5 66rc*[[RRR S5S5n[ R S:XaSUS3/nOSU3S/nUHn[R"U5s $ [S5e![a M6f=f) N.rr nvrtc64_z0_0.dllz libnvrtc.so.z libnvrtc.soz Could not find any NVRTC library) inttorchversioncudasplitr r r r OSError) major_version nvrtc_libslib_names r_get_nvrtc_libraryr, s **005a89M ||w}oW - =/ *   ;;x( ( 4 55   sB BB kernel_source kernel_namecompute_capability header_codecuda_include_dirs nvcc_optionsc ^^SSKn[5mSmS[SS4UU4SjjnUR5R S5(dSU3nU(a US-U-nOUnUR S 5n UcMUR RUR R55n U RU R3n/n U RS U3R 55 U(a+UH%n U RS U 3R 55 M' U(a)UH#n U RU R S 55 M% SS K J n UVs/sH oS :wdM UPM nnU RUVs/sHoR S 5PM sn5 [U 5n[ R"U-"U 6n[ R$"5nU"TR'[ R("U5U US3R 5SSS55 TR+UUU5nUT:wa[ R,"5nTR/U[ R("U55 [ R0"UR25nTR5UU5 [7SUR2R9535e[ R,"5nU"TR;U[ R("U555 [ R0"UR25nU"TR=UU55 TR?[ R("U55 UR2$s snfs snf)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. header_code (str, optional): Additional header code to prepend to the kernel source cuda_include_dirs (list, None): List of directories containing CUDA headers nvcc_options (list, None): Additional options to pass to NVRTC Returns: str: The compiled PTX code rNrrc>UT:war[R"5nTRU[R"U55 URbURR 5OSn[ SU35eg)Nrr)r rnvrtcGetErrorStringrrrr)rrr NVRTC_SUCCESSlibnvrtcs r check_nvrtc#_nvrtc_compile..check_nvrtcTso ] "oo'G  ( (g1F G==, $$&)  m_=> > #rz extern "C"z extern "C"  utf-8z--gpu-architecture=sm_z-I)COMMON_NVCC_FLAGSz--expt-relaxed-constexprz.cuzKernel compilation failed: ) torch.cudar,r#strip startswithencoder&get_device_propertiescurrent_devicemajorminorappendtorch.utils.cpp_extensionr<extendlenr rc_void_pnvrtcCreateProgramrnvrtcCompileProgramc_size_tnvrtcGetProgramLogSizecreate_string_bufferrnvrtcGetProgramLogrrnvrtcGetPTXSize nvrtcGetPTXnvrtcDestroyProgram)r-r.r/r0r1r2r$r8 full_source source_bytespropsoptions directoryoptionr<flagnvrtc_compatible_flags num_options options_arrayprogreslog_sizelogptx_sizeptxr6r7s @@r_nvrtc_compilerc3s0"#HM ?C ?D ? ?    + +L 9 9%m_5 !D(=8 # %%g.L! 001J1J1LM % }U[[M:G NN+,>+?@GGIJ*I NNR {+224 5+"F NN6==1 2#<+*6P.P* NN5KL5KTKK(5KLMg,K__{2W=M ?? D## LL  m3  & & (       & &t[- HC m??$''fll8.DE))(..9##D#.9#)):J:J:L9MNOO H((v||H/EFG  % %hnn 5C$$T3/0   d!34 99SMs M"M"4M'cL\rSrSrS\R SS4SjrS\SS4SjrS r g) _CudaModulemodulerNcXl0UlgN)_module_kernels)selfrgs r__init___CudaModule.__init__s 02 rname _CudaKernelc XR;aURU$SSKJn U"5n[R"5n[ UR [R"U5URURS555 [X@R5nXPRU'U$![an[SUS35UeSnAff=f)Nr)rr;zNo kernel named 'z' in this module) rktorch.cuda._utilsrr rIrcuModuleGetFunctionrrjr@rprAttributeError)rlrorrfunckernelerrs r __getattr___CudaModule.__getattr__s == ==& & 8#%  V ++LL& dkk'6J  !||4F"(MM$ M V #4TF:J!KLRU U VsA-B00 C:C  C)rkrj) __name__ __module__ __qualname____firstlineno__r rIrmstrrx__static_attributes__rrrreres/3v343VV Vrrec \rSrSrSrS\R S\R SS4SjrSS\\ \ \ 4S \\ \ \ 4S \ \ S \ S \ \ SS4 S jjr Srg)rpzL Represents a compiled CUDA kernel that can be called with PyTorch tensors. rurgrNcXlX lgrirurg)rlrurgs rrm_CudaKernel.__init__s   rgridblockargs shared_memstreamcSSKnURRR5nU(d/n/n/n UGHvn [ XR 5(aU R (d1U R(aU R5(d [S5e[R"U R55n URU 5 U R[R"U 55 M[ U [5(a>[R "U 5n U R[R"U 55 GM[ U ["5(a>[R$"U 5n U R[R"U 55 GMb['S[)U 535e [R[+U 5-"5n[-U 5H,up[R."U [R5X'M. UcSSKnURR35n[5UR7UR8USUSUSUSUSUSUUR:US5 5 g)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: )r$r&_utilsr isinstanceTensoris_cudais_cpu is_pinned ValueErrorr rIdata_ptrrErr#c_intfloatc_float TypeErrortyperH enumeratecastr=current_streamrcuLaunchKernelru_as_parameter_)rlrrrrrr$rprocessed_argsc_argsargptrrr c_args_arrayis r__call___CudaKernel.__call__s& **##557D13C#||,,{{CJJ3==??$Yooclln5%%c* fll3/0C%% S) fll512C'' ..- fll734"=d3i[ IJJ-2#f+58 'FA$kk#v?LO( > ZZ..0F  " " QQQaaa%%  rr)rrrrNrN)rzr{r|r}__doc__r rIrmtupler#rlistrrrrrrrprpsV__foo$ &/&/# $ P CcM"P S#s]#P tn P  P  P  P P rrprb kernel_namesc \SSKn[5n[U[5(aUR S5n[ R "5nURR5nU [UR[ R"U5U55 SSS5 U(d [U5$0nUHcn[ R "5n[UR[ R"U5XGR S555 [X5Xg'Me U$!,(df  N=f)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. rNr;)r=rrr~r@r rIr&rrcuModuleLoadDatarrersrp) rbrr$rrgrkernelsrorus r_cuda_load_moduler(s  !G#sjj!__ F ZZ & & (F G,,V\\&-A3GH  6""G   ' ' T"FKK,@  $D1  N! s &0D D+deviceoptional allow_cpuc[U[5(aU$[U[5(a[R"U5n[U[R5(aDU(aUR S;a[ SU35eOUR S:wa[ SU35e[RR5(d5[U[RR5(a UR$[XU5$)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``. )r&cpuz(Expected a cuda or cpu device, but got: r&z!Expected a cuda device, but got: ) rr#r~r$rrrjit is_scriptingr&idx_torch_get_device_index)rrrs rrrXs &# &#f%&%,,'' {{/1 #KF8!TUU2 [[F "@IJ J 99 ! ! # # fejj// 0 0::  "6Y ??r)NNNri)FF)r r typingrrrr$ torch._utilsrrr rr#rr,r~rbytesrcrerpdictrboolrrrrsK '' F+6;;+ 7 7 76FKK6,)-(,#' yyy! y y  ~ y 4. y yxVV:Y Y zAE- sEz -*249*=- ;S-/0 01-b