U yho@s UdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z mZmZmZmZddlZddlZddlmZddlmZddlmZmZmZd d lmZd d lmZm Z m!Z!m"Z"m#Z#d d l$m%Z%m&Z&m'Z'zdd lm(Z(Wne)k rdZ(YnXda*e+Z,e-Z.ga/eee gdfee0fe1d<e2ej3dddZ4eee0e5dfZ6dZ7dZ8zTzddl9Z9dZ7Wne:k rYnXzddl;Z;dZ7Wne:k rYnXWn(e)k rZ<zeej3drej3j?Z?nedZ?e>ej3dr0ej3j@ZAne5e5dddZAe>ej3drXej3jBZCne5e5dddZCdZDeEe1d<ej3jFZGeEe1d<dZHeej3jIe1d<eEd d!d"ZJeEd d#d$ZKeEd d%d&ZLdeEd'd(d)ZMe d*d+e6dd,d-ZNd.d/ZOe0d0d1d2ZPd3d4ZQd5d6ZRd7d8ZSd9d:ZTeTeQeTeRGd;d<dZXd?d@ZYdAdBZZGdCdDdDZ[GdEdFdFe\Z]e5ddGdHdIZ^GdJdKdKZ_GdLdMdMZGdNdOdOeZ`e6dddPdQZadee6e0ddRdSZbdee6ee5e5fddTdUZce6e?ddVdWZde6e6eEdXdYdZZeGd[d\d\Zfed]efd^d_d`ZgdadbZhe'dcdddeZieee5ee0fd dfdgZje5d dhdiZke5d djdkZleee0d dldmZmeee0d dndoZnee0ee0ee5dpdqdrZoe5d dsdtZpe5d dudvZqeee5efe5ddwdxZrdasee5e1dy<e5d dzd{Ztee0d d|d}Zue0d d~dZve5d ddZwde6ddddZxddZydee6e'dddZzdee6e'dddZ{ddZ|ee5e0fddddZ}e5d ddZ~deeee5fdddZdeeee5fdddZeee5efe5dddZdeeee5fe5dddZd eeee5fe5dddZd!eeee5fe5dddZd"eeee5fe5dddZd#eeee5fe5dddZd$eeee5fe5dddZd%eeee5fe5dddZd&eeee5fe5dddZd'eeee5fe5dddZd(eeee5fe5dddZee5e0ejfejdddZejej3jIdddZd)e5ee5e0ejfddddZd*ee5e0ejfe5dddZd dlTd dlTeddZGdddZddlmZmZGdddeZGdddeZGdddeZGdd„deZGddĄdeZGddƄdeZGddȄdeZGddʄdeZGdd̄deZGdd΄deZGddЄdeZGdd҄deZGddԄdeZ[[ejeejeejeejeejeejeejeejeejeejeejeejeGddքdփZdd؄ZeTed dlmZmZmZmZmZmZddddddddddddddddddddddddFdddd&d)dd8dddddddddddddddddddddddd d d d d ddddQddddeddd`ddddgoZdS(+aM This package adds support for CUDA tensor types. It implements the same function as CPU tensors, but they utilize GPUs for computation. It is lazily initialized, so you can always import it, and use :func:`is_available()` to determine if your system supports CUDA. :ref:`cuda-semantics` has more details about working with CUDA. N) lru_cache)AnyCallablecastListOptionalTupleUnion)Devicedevice) _dummy_type_LazySeedTracker classproperty)_get_device_index) CUDAGraphgraphgraph_pool_handleis_current_stream_capturingmake_graphed_callables)EventExternalStreamStream)_cudartF _queued_callsZ_cuda_isInBadForkcCsdSNFrrrE/var/www/html/venv/lib/python3.8/site-packages/torch/cuda/__init__.py3r T_CudaDeviceProperties_cuda_exchangeDevice)r returncCs|dkr dStddSNrz)PyTorch was compiled without CUDA support RuntimeErrorr rrr_exchange_deviceTsr)_cuda_maybeExchangeDevicecCs|dkr dStddSr%r'r rrr_maybe_exchange_device^sr+has_half has_magmardefault_generators)r$cCs ttjdS)z)Return true if compile with CUDA support._cuda_getDeviceCount)hasattrtorch_Crrrr _is_compiledjsr3cCstddkS)NZPYTORCH_NVML_BASED_CUDA_CHECK1)osgetenvrrrr_nvml_based_availosr7cCs,ts dStrtdkStjdkSdS)z8Return a bool indicating if CUDA is currently available.FrN)r3r7 device_countr1r2r/rrrr is_availabless  r9)including_emulationcCsbtjjr dStj}tjj}|dk rRt|dddkrRtj|jdkrRdS|sZdSt |S)zQReturn a bool indicating if the current CUDA/ROCm device supports dtype bfloat16.TN.r F) r1versionhipcudacurrent_deviceintsplitget_device_propertiesmajor_check_bf16_tensor_supported)r:r Z cuda_versionrrris_bf16_supporteds rG)maxsizecCs6ztjdgtj|dWdStk r0YdSXdS)Ng?)dtyper TF)r1Ztensorbfloat16 Exceptionr rrrrFs rFcCstj|dSN)r1r2Z _cuda_sleep)Zcyclesrrr_sleepsrN) arch_stringcCs,|dd}|dr$|dd}t|S)z4Extracts the architecture string from a CUDA version_raNr&)rCendswithrB)rObaserrr_extract_arch_versions  rTc Csd}d}tjjdk rtj}ttD]v}t|}|d}|d}t|}|d|}t ddtj Ddd } || kr(t |||||| d| dfq(dS) Nz Found GPU%d %s which requires CUDA_VERSION >= %d to work properly, but your PyTorch was compiled with CUDA_VERSION %d. Please install the correct PyTorch binary using instructions from https://pytorch.org z Found GPU%d %s which is of cuda capability %d.%d. PyTorch no longer supports this GPU because it is too old. The minimum cuda capability supported by this library is %d.%d. rr css|]}t|VqdSrMrT.0archrrr sz$_check_capability..#)default) r1r>r@r2Z_cuda_getCompiledVersionranger8get_device_capabilityget_device_namemin get_arch_listwarningswarn) Zincorrect_binary_warnZ old_gpu_warnZ CUDA_VERSIONd capabilityrEminornameZ current_archZmin_archrrr_check_capabilitys(   rhc sd}tjjdkrdSt}t|dkr*dSdd|D}ttD]Z}t|\}tfdd|D}|sBt |}d|}t | ||d ||qBdS) Na  {} with CUDA capability sm_{} is not compatible with the current PyTorch installation. The current PyTorch install supports CUDA capabilities {}. If you want to use the {} GPU with PyTorch, please check the instructions at https://pytorch.org/get-started/locally/ rcSsg|]}d|krt|qS)Zsm_rVrWrrr sz!_check_cubins..c3s|]}|dkVqdS)rUNr)rXsmZ cap_majorrrrZsz _check_cubins..rU )r1r>r@ralenr]r8r^anyr_rbrcformatjoin)Zincompatible_device_warn arch_listZ supported_smidxZ cap_minor supportedZ device_namererrkr _check_cubinss*    rtcCs to t S)z9Return whether PyTorch's CUDA state has been initialized.) _initialized_is_in_bad_forkrrrris_initializedsrwcKs`tr|nN|ddr,t|tn0|ddrJt|tnt|tfdS)Nseed_allFseed) rwget_lazy_seed_trackerZqueue_seed_all traceback format_stackZ queue_seedrappend)callablekwargsrrr _lazy_calls  rc@s eZdZdS)DeferredCudaCallErrorN)__name__ __module__ __qualname__rrrrrsrcCs tdS)aInitialize PyTorch's CUDA state. You may need to call this explicitly if you are interacting with PyTorch via its C API, as Python bindings for CUDA functionality will not be available until this initialization takes place. Ordinary users should not need this, as all of PyTorch's CUDA methods automatically initialize CUDA state on-demand. Does nothing if the CUDA state is already initialized. N) _lazy_initrrrrinits rc Cs(tsttdrdSttr0W5QRdStr>tdttjdsRtdt dkrbtddt j krvdt j d<tj dt_ tD]}|rt|qzftD]\\}}z |Wqtk r}z(d t|d d |}t||W5d}~XYqXqW5ttdXdaW5QRXdS) Nis_initializingzwCannot re-initialize CUDA in forked subprocess. To use CUDA with multiprocessing, you must use the 'spawn' start methodr/z$Torch not compiled with CUDA enabledzGlibcudart functions unavailable. It looks like you have a broken build?ZCUDA_MODULE_LOADINGZLAZYTz6CUDA call failed lazily at initialization with error: z( CUDA call was originally invoked at: )rwr0_tls_initialization_lockrvr(r1r2AssertionErrorrr5environZ _cuda_initrr{Z get_callsrr~delattrrLstrrprru)ZcallsZ queued_callZorig_tracebackemsgrrrrs@        " rcCs ttSrM)rrrrrrcudartSsrc@s&eZdZUdZeed<dZeed<dS) cudaStatusrSUCCESS"ERROR_NOT_READYN)rrrrrB__annotations__rrrrrrXs  rcs$eZdZeddfdd ZZS) CudaErrorN)coder$cs,tt|}t|d|ddS)Nz ())rZcudaGetErrorString cudaErrorsuper__init__)selfrr __class__rrr^szCudaError.__init__)rrrrBr __classcell__rrrrr]sr)resr$cCs|tjjkrt|dSrM)rrsuccessr)rrrr check_errorcs rc@s4eZdZedddZddZeeedddZd S) _DeviceGuard)indexcCs||_d|_dSNr&)rrprev_idx)rrrrrrisz_DeviceGuard.__init__cCstj|j|_dSrMr1r@r)rrrrrrr __enter__msz_DeviceGuard.__enter__typevaluer|cCstj|j|_dSrr1r@r+rrrrrrr|rrr__exit__psz_DeviceGuard.__exit__N)rrrrBrrrrrrrrrhsrc@s8eZdZdZedddZddZeeeddd Zd S) r zContext-manager that changes the selected device. Args: device (torch.device or int): device index to select. It's a no-op if this argument is a negative integer or ``None``. r cCst|dd|_d|_dS)NToptionalr&)rrrr)rr rrrr}szdevice.__init__cCstj|j|_dSrMrrrrrrszdevice.__enter__rcCstj|j|_dSrrrrrrrszdevice.__exit__N)rrr__doc__rrrrrrrrr usr cs eZdZdZfddZZS) device_ofaContext-manager that changes the current device to that of given object. You can use both tensors and storages as arguments. If a given object is not allocated on a GPU, this is a no-op. Args: obj (Tensor or Storage): object allocated on the selected device. cs"|jr|nd}t|dSr)is_cuda get_devicerr)robjrrrrrrszdevice_of.__init__)rrrrrrrrrrrs rcCs t|}|dkrtj|dS)a=Set the current device. Usage of this function is discouraged in favor of :any:`device`. In most cases it's better to use ``CUDA_VISIBLE_DEVICES`` environmental variable. Args: device (torch.device or int): selected device. This function is a no-op if this argument is negative. rN)rr1r2Z_cuda_setDevicer rrr set_devices rcCs t|jS)aGet the name of a device. Args: device (torch.device or int or str, optional): device for which to return the name. This function is a no-op if this argument is a negative integer. It uses the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Returns: str: the name of the device )rDrgr rrrr_s r_cCst|}|j|jfS)aGet the cuda capability of a device. Args: device (torch.device or int or str, optional): device for which to return the device capability. This function is a no-op if this argument is a negative integer. It uses the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Returns: tuple(int, int): the major and minor cuda capability of the device )rDrErf)r proprrrr^s r^cCs4tt|dd}|dks$|tkr,tdt|S)zGet the properties of a device. Args: device (torch.device or int or str): device for which to return the properties of the device. Returns: _CudaDeviceProperties: the properties of the device TrrInvalid device id)rrr8rZ_get_device_propertiesr rrrrDs  rD)r peer_devicer$cCs\tt|dd}t|}|dks,|tkr4td|dksF|tkrNtdtj||S)z5Check if peer access between two devices is possible.TrrrzInvalid peer device id)rrr8rr1r2Z_cuda_canDeviceAccessPeer)r rrrrcan_device_access_peers rc@sJeZdZUdZeded<eddddZddZeeed d d Z d S) StreamContextaContext-manager that selects a given stream. All CUDA kernels queued within its context will be enqueued on a selected stream. Args: Stream (Stream): selected stream. This manager is a no-op if it's ``None``. .. note:: Streams are per-device. torch.cuda.Stream cur_streamstreamcCsh||_tdd|_tjs,|jdkr,d|_tjs:dn tjd|_tjsVdn tjd|_ dS)NTr&) rrrrr1ZjitZ is_scriptingr@default_streamsrc_prev_streamdst_prev_stream)rrrrrrs   zStreamContext.__init__c Csn|j}|dks|jdkrdStjd|_|jj|jkr^t|jtj|j|_W5QRXtj|dSr) rrrr1r@current_streamrr r set_stream)rrrrrrs zStreamContext.__enter__rcCsJ|j}|dks|jdkrdS|jj|jkr8tj|jtj|jdSr)rrrrr r1r@rr)rrrr|rrrrrs zStreamContext.__exit__N) rrrrrrrrrrrrrrrs  rr)rr$cCst|S)aMWrap around the Context-manager StreamContext that selects a given stream. Arguments: stream (Stream): selected stream. This manager is a no-op if it's ``None``. ..Note:: In eager mode stream is of type Stream class while in JIT it is an object of the custom class ``torch.classes.cuda.Stream``. )rrrrrrs rcCstjj|||ddS)zset stream specified by the stream id, device index and device type Args: stream_id (int): stream id in stream pool device_index (int): device index in topo device_type (int): enum device type  stream_id device_index device_typeN)r1r2Z_cuda_setStreamrrrr_set_stream_by_id(s rrcCs$|dkr dSt|j|j|jddS)aSet the current stream.This is a wrapper API to set the stream. Usage of this function is discouraged in favor of the ``stream`` context manager. Args: stream (Stream): selected stream. This function is a no-op if this argument is ``None``. Nr)rrrrrrrrr7s rcCsttjjsdnd}|dkr*ttdSttddd}ttt tdd d }| d rd||d S| d rx||d Sg}| d D]@}|| }||krt t tgS|dkrq||q|S)z0Parse CUDA_VISIBLE_DEVICES environment variable.ZCUDA_VISIBLE_DEVICESZHIP_VISIBLE_DEVICESN@)sr$cSsj|sdSt|D]<\}}|s4|dkr0|dks4qN|dt|kr|d7}q|dkrft|d|SdS)z:Return -1 or positive integer sequence string starts with.r&rz+-rN) enumerateisdigitrmrB)rrrcrrr_strtoulQs z(_parse_visible_devices.._strtoul)lstprefixr$cSsJg}|dD]6}||kr,tttgS||s:qF||q|S)N,)rCrrr startswithr~)rrrcselemrrrparse_list_with_prefix\s  z6_parse_visible_devices..parse_list_with_prefixzGPU-MIG-rr)r5r6r1r>r?listr]rrBrrrCstriprr~)varrrrcrxrrr_parse_visible_devicesIs(        rc CsbtsdSz tWn<tjk rP}ztd|jWYdSd}~XYnXt}t|S)Nr&z&Can't initialize amdsmi - Error code: ) _HAS_PYNVMLamdsmi amdsmi_initAmdSmiExceptionrbrcZerr_codeamdsmi_get_processor_handlesrm)rsocket_handlesrrr_raw_device_count_amdsmi{s rcCsnddlm}m}m}|d}|}|dkr:tddS|d}|||}|dkrftddS~|jS)zgReturn number of devices as reported by NVML or negative value if NVML discovery/initialization failed.r)byrefc_intCDLLlibnvidia-ml.so.1Can't initialize NVMLr&Can't get nvml device count) ctypesrrrnvmlInitrbrcnvmlDeviceGetCount_v2r)rrrnvml_hr dev_countrrr_raw_device_count_nvmls  rc Csddlm}m}m}m}m}ts$dSz tWn"tj k rRt dYdSXzt }t |}Wn"tj k rt dYdSXg}t|D]~}zt |} Wn$tj k rt dYdSXzt| } Wn&tj k rt dYdSX|t| q|S)Nrrrc_void_prcreate_string_bufferzCan't initialize amdsmizCan't get amdsmi device countzCannot get amd device handlerzCannot get uuid for amd device)rrrrrrrrrrrbrcrrmr]Zamdsmi_get_gpu_device_uuidr~r) rrrrrrruuidsrrhandleruuidrrr_raw_device_uuid_amdsmis8         rc Csddlm}m}m}m}m}|d}|}|dkrBtddS|d}| ||}|dkrntddSg}t |j D]|} |} | | || }|dkrtddSd } || } | | | | }|dkrtd dS|| jd d q|~|S) z^Return list of device UUID as reported by NVML or None if NVM discovery/initialization failed.rrrrNr&rzCan't get device handle`zCan't get device UUIDascii)rrrrrrrrbrcrr]rZnvmlDeviceGetHandleByIndex_v2ZnvmlDeviceGetUUIDr~rawdecoder) rrrrrrrrrrrZdev_idZbuf_lenbufrrr_raw_device_uuid_nvmls6    r) candidatesrr$cCsbttttddd}g}|D]>}|||}|dkr8q^||krRtttgS||q|S)zqGiven the set of partial uuids and list of known uuids builds a set of ordinals excluding ambiguous partials IDs.) candidaterr$cSs8d}t|D]&\}}||s q |dkr.dS|}q |Sr)rr)rr best_matchrrrrrruuid_to_orinals z3_transform_uuid_to_ordinals..uuid_to_orinalr)rrrBrr~)rrrrrrrrrr_transform_uuid_to_ordinalss   rcCst}|sdSzXt|dtkr&WdSt}|dkr:|WSt|D] \}}tt||krB|WSqBWn*tk r|YdStk rYdSXt |S)Nrr&) rrrrrrrBOSErrorAttributeErrorrm)visible_devicesraw_cntrrvalrrr_device_count_amdsmis"r cCst}|sdSzt|dtkr^|ddr4WdSt}|dkrHWdStttt||}n>t}|dkrr|WSt |D] \}}tt ||krz|WSqzWn*t k rYdSt k rYdSXt |S)zReturn number of devices as reported by NVML taking CUDA_VISIBLE_DEVICES into account. Negative value is returned if NVML discovery or initialization has failed. rrr&N)rrrrrrrrrrrBrrrm)r rr rrr rrr_device_count_nvml s2 r cCst|dd}t}t|dtkrLt}|dkr8tdtttt||}ttt |}|dksn|t |krtd|d|d||S) zNReturn the NVML index of the device, taking CUDA_VISIBLE_DEVICES into account.TrrNzCan't get device UUIDsdevice z& is not visible (CUDA_VISIBLE_DEVICES=r) rrrrrr(rrrrBrm)r rrr rrrr_get_nvml_device_index,s   r_cached_device_countcCsLts dStdk rtStjjr$tnt}|dkrr?r r r2r/ru)Z nvml_countrrrrr8Bsr8cCs(ts gStj}|dkr gS|S)z=Return list CUDA architectures this library was compiled for.N)r9r1r2Z_cuda_getArchFlagsrC)Z arch_flagsrrrraTs  racCs8t}t|dkrdSdd|D}ddd|DS)z9Return NVCC gencode flags this library was compiled with.rrcSsg|]}|dqS)rP)rCrWrrrricsz%get_gencode_flags..rlcSs&g|]\}}d|d|d|qS)z-gencode compute=compute_z,code=rPr)rXkindrYrrrries)rarmrp)rqZ arch_list_rrrget_gencode_flags^s rcCsttjS)z0Return the index of a currently selected device.)rr1r2Z_cuda_getDevicerrrrrAlsrAc Cs4ttj|tjW5QRSQRXdS)a,Wait for all kernels in all streams on a CUDA device to complete. Args: device (torch.device or int, optional): device for which to synchronize. It uses the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). N)rr1r@r r2Z_cuda_synchronizer rrr synchronizersrcCsttjS)axForce collects GPU memory after it has been released by CUDA IPC. .. note:: Checks if any sent CUDA tensors could be cleaned from the memory. Force closes shared memory file used for reference counting if there is no active counters. Useful when the producer process stopped actively sending tensors and want to release unused memory. )rr1r2Z_cuda_ipc_collectrrrr ipc_collects rcCs4ttjt|dd}t|d|d|ddS)aSReturn the currently selected :class:`Stream` for a given device. Args: device (torch.device or int, optional): selected device. Returns the currently selected :class:`Stream` for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Trrrr r)rr1r2Z_cuda_getCurrentStreamrrr Z streamdatarrrrs  rcCs4ttjt|dd}t|d|d|ddS)a=Return the default :class:`Stream` for a given device. Args: device (torch.device or int, optional): selected device. Returns the default :class:`Stream` for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Trrrr r)rr1r2Z_cuda_getDefaultStreamrrrrrrrs  rcCsttjS)z6Return cublasHandle_t pointer to current cuBLAS handle)rr1r2Z_cuda_getCurrentBlasHandlerrrrcurrent_blas_handlesr) debug_moder$cCsRtt|trB|dkrd}n$|dkr,d}n|dkr:d}ntdtj|dS) aSet the debug mode for cuda synchronizing operations. Args: debug_mode(str or int): if "default" or 0, don't error or warn on synchronizing operations, if "warn" or 1, warn on synchronizing operations, if "error" or 2, error out synchronizing operations. Warning: This is an experimental feature, and not all synchronizing operations will trigger warning or error. In particular, operations in torch.distributed and torch.sparse namespaces are not covered yet. r\rrcrerrorr zGinvalid value of debug_mode, expected one of `default`, `warn`, `error`N)r isinstancerr(r1r2Z_cuda_set_sync_debug_mode)rrrrset_sync_debug_modes  rcCsttjS)zEReturn current value of debug mode for cuda synchronizing operations.)rr1r2Z_cuda_get_sync_debug_moderrrrget_sync_debug_modesrc Csjtstdtddlm}z tWn,|k rR}ztd|W5d}~XYnXt|}t|}|S)Nz=pynvml does not seem to be installed or it can't be imported.r)NVMLError_DriverNotLoadedz-cuda driver can't be loaded, is cuda enabled?) rModuleNotFoundError _PYNVML_ERRpynvmlrrr(rnvmlDeviceGetHandleByIndex)r rrhandlerrr_get_pynvml_handlers   r#c Csbtstdtz tWn.tjk rH}ztd|W5d}~XYnXt|}t|}|S)Nz=amdsmi does not seem to be installed or it can't be imported.z>amdsmi driver can't be loaded, requires >=ROCm5.6 installation) rrrrrrr(_get_amdsmi_device_indexr)r rr"rrr_get_amdsmi_handlers"  r%cCsft|dd}t}t|dtkr*tdttttt |}||kr^td|d|d||S)zOReturn the amdsmi index of the device, taking HIP_VISIBLE_DEVICES into account.Trrz5HIP_VISIBLE_DEVICES should be indices and not stringsrz% is not visible (HIP_VISIBLE_DEVICES=r) rrrrr(dictrrrrB)r rrr Zidx_maprrrr$s r$cCst}t|}t|dS)NZ vram_used)r%r$rZamdsmi_get_gpu_vram_usager r"rrr_get_amdsmi_memory_usagesr(cCs(t}t|}t|}t|dS)NZ gfx_activity)r%r$rrZamdsmi_get_gpu_activityr'rrr_get_amdsmi_utilization s r)cCst|}t|tjjtjjSrM)r%rZamdsmi_get_temp_metricZAmdSmiTemperatureTypeZJUNCTIONZAmdSmiTemperatureMetricZCURRENTr'rrr_get_amdsmi_temperatures r*cCst|}t|dS)NZcurrent_socket_power)r%rZamdsmi_get_power_infor'rrr_get_amdsmi_power_drawsr+cCst|}t|tjjdS)NZcur_clk)r%rZamdsmi_get_clock_infoZ AmdSmiClkTypeZGFXr'rrr_get_amdsmi_clock_rate!sr,cCs8tjjs,t}t|}t|}t|jSt |SdS)aReturn the percent of time over the past sample period during which global (device) memory was being read or written as given by `nvidia-smi`. Args: device (torch.device or int, optional): selected device. Returns statistic for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Warning: Each sample period may be between 1 second and 1/6 second, depending on the product being queried. N) r1r>r?r#rr r!nvmlDeviceGetUtilizationRatesmemoryr(r'rrr memory_usage&s   r/cCs:tjjs.t|}t|}t|}t|jSt |SdS)aReturn the percent of time over the past sample period during which one or more kernels was executing on the GPU as given by `nvidia-smi`. Args: device (torch.device or int, optional): selected device. Returns statistic for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Warning: Each sample period may be between 1 second and 1/6 second, depending on the product being queried. N) r1r>r?r#rr r!r-Zgpur)r'rrr utilization;s   r0cCs(tjjst|}t|dSt|SdS)a Return the average temperature of the GPU sensor in Degrees C (Centigrades). The average temperature is computed based on past sample period as given by `nvidia-smi`. Args: device (torch.device or int, optional): selected device. Returns statistic for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Warning: Each sample period may be between 1 second and 1/6 second, depending on the product being queried. rN)r1r>r?r#r ZnvmlDeviceGetTemperaturer*r'rrr temperaturePs  r1cCs&tjjst|}t|St|SdS)a Return the average power draw of the GPU sensor in mW (MilliWatts) over the past sample period as given by `nvidia-smi` for Fermi or newer fully supported devices. Args: device (torch.device or int, optional): selected device. Returns statistic for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Warning: Each sample period may be between 1 second and 1/6 second, depending on the product being queried. N)r1r>r?r#r ZnvmlDeviceGetPowerUsager+r'rrr power_drawes  r2cCs(tjjst|}t|dSt|SdS)aReturn the clock speed of the GPU SM in Hz Hertz over the past sample period as given by `nvidia-smi`. Args: device (torch.device or int, optional): selected device. Returns statistic for the current device, given by :func:`~torch.cuda.current_device`, if :attr:`device` is ``None`` (default). Warning: Each sample period may be between 1 second and 1/6 second, depending on the product being queried. rN)r1r>r?r#r ZnvmlDeviceGetClockInfor,r'rrr clock_ratexs  r3cCs0t|trt|}nt|tr,td|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int): selected device. r@)rrr1r rBr rrr _get_devices     r4cCs |j}|dkrt}tjj|S)zvReturn the CUDA Generator object for the given device. Args: device (torch.device): selected device. N)rrAr1r@r.)r rrrrr_get_generatorsr5r@)offsetr r$cs"t|fdd}t|dS)a'Set the random number generator state offset of the specified GPU. Args: offset (int): The desired offset device (torch.device or int, optional): The device to set the RNG state. Default: ``'cuda'`` (i.e., ``torch.device('cuda')``, the current CUDA device). cst}|dSrM)r5Z set_offset)default_generator final_devicer6rrcbsz!_set_rng_state_offset..cbN)r4r)r6r r:rr8r_set_rng_state_offsets r;cCstt|}t|}|S)aPReturn the random number generator state offset of the specified GPU. Args: device (torch.device or int, optional): The device to return the RNG state offset of. Default: ``'cuda'`` (i.e., ``torch.device('cuda')``, the current CUDA device). .. warning:: This function eagerly initializes CUDA. )rr4r5Z get_offset)r r9r7rrr_get_rng_state_offsets r<)*cOsttt|j|f||SrM)rr _CudaBase__new__clsargsrrrr _lazy_newsrCcs(eZdZdZdZfddZeZZS)r>TFc s2t|tj||W5QRSQRXdSrM)r rrr)rrBrrrrrsz_CudaBase.type) rrrrZ is_sparserrCr?rrrrrr>s r>)_LegacyStorage_warn_typed_storage_removalc@s8eZdZeddZeddZedddddZdS) _CudaLegacyStoragecOsttddS)Nz+from_buffer: Not available for CUDA storage)rEr(r@rrr from_buffersz_CudaLegacyStorage.from_buffercOs tddS)Nz2_new_with_weak_ptr: Not available for CUDA storager'r@rrr_new_with_weak_ptrsz%_CudaLegacyStorage._new_with_weak_ptrN)r rJcCs tddS)Nz4_new_shared_filename: Not available for CUDA storager')rAmanagerrsizer rJrrr_new_shared_filenamesz'_CudaLegacyStorage._new_shared_filename)rrr classmethodrGrHrKrrrrrFs   rFc@s$eZdZeddZeddZdS) ByteStoragecCs t|jSrMrE_dtyperrrrrJszByteStorage.dtypecCstjSrM)r1Zuint8rrrrrOszByteStorage._dtypeNrrrrrJrOrrrrrMs rMc@s$eZdZeddZeddZdS) DoubleStoragecCs t|jSrMrNrrrrrJszDoubleStorage.dtypecCstjSrM)r1doublerrrrrO szDoubleStorage._dtypeNrPrrrrrQs rQc@s$eZdZeddZeddZdS) FloatStoragecCs t|jSrMrNrrrrrJszFloatStorage.dtypecCstjSrM)r1floatrrrrrOszFloatStorage._dtypeNrPrrrrrSs rSc@s$eZdZeddZeddZdS) HalfStoragecCs t|jSrMrNrrrrrJszHalfStorage.dtypecCstjSrM)r1ZhalfrrrrrOszHalfStorage._dtypeNrPrrrrrUs rUc@s$eZdZeddZeddZdS) LongStoragecCs t|jSrMrNrrrrrJ%szLongStorage.dtypecCstjSrM)r1longrrrrrO*szLongStorage._dtypeNrPrrrrrV$s rVc@s$eZdZeddZeddZdS) IntStoragecCs t|jSrMrNrrrrrJ0szIntStorage.dtypecCstjSrM)r1rBrrrrrO5szIntStorage._dtypeNrPrrrrrX/s rXc@s$eZdZeddZeddZdS) ShortStoragecCs t|jSrMrNrrrrrJ;szShortStorage.dtypecCstjSrM)r1shortrrrrrO@szShortStorage._dtypeNrPrrrrrY:s rYc@s$eZdZeddZeddZdS) CharStoragecCs t|jSrMrNrrrrrJFszCharStorage.dtypecCstjSrM)r1Zint8rrrrrOKszCharStorage._dtypeNrPrrrrr[Es r[c@s$eZdZeddZeddZdS) BoolStoragecCs t|jSrMrNrrrrrJQszBoolStorage.dtypecCstjSrM)r1boolrrrrrOVszBoolStorage._dtypeNrPrrrrr\Ps r\c@s$eZdZeddZeddZdS)BFloat16StoragecCs t|jSrMrNrrrrrJ\szBFloat16Storage.dtypecCstjSrM)r1rKrrrrrOaszBFloat16Storage._dtypeNrPrrrrr^[s r^c@s$eZdZeddZeddZdS)ComplexDoubleStoragecCs t|jSrMrNrrrrrJgszComplexDoubleStorage.dtypecCstjSrM)r1ZcdoublerrrrrOlszComplexDoubleStorage._dtypeNrPrrrrr_fs r_c@s$eZdZeddZeddZdS)ComplexFloatStoragecCs t|jSrMrNrrrrrJrszComplexFloatStorage.dtypecCstjSrM)r1ZcfloatrrrrrOwszComplexFloatStorage._dtypeNrPrrrrr`qs r`c@s eZdZdZddZddZdS)_WrappedTritonKernelzBJust a simple wrapper to store some metadata for testing purposes.cCs||_d|_dSrkernelZkernel_invoked)rrcrrrrsz_WrappedTritonKernel.__init__cOs|j||}d|_|S)NTrb)rrBrrrrr__call__s z_WrappedTritonKernel.__call__N)rrrrrrdrrrrrasracCs`tr dStdd}tdd}tjddk }|r\tjdd|dtjd d |ddS) Nc_sddlm}||ddi|S)Nr) bsr_dense_mm skip_checksT)torch.sparse._triton_opsre)rBrrerrr kernel_impls z-_register_triton_kernels..kernel_implc_sddlm}||ddi|S)Nr)bsr_dense_addmmrfT)rgri)rBrrirrraddmm_kernel_impls z3_register_triton_kernels..addmm_kernel_implZtritonZ_triton_bsr_dense_mm_outzS_triton_bsr_dense_mm_out(Tensor bsr, Tensor dense, *, Tensor(a!) out) -> Tensor(a!)Z SparseCsrCUDAZ_triton_bsr_dense_addmm_outz_triton_bsr_dense_addmm_out(Tensor input, Tensor bsr, Tensor dense, *, Scalar beta, Scalar alpha, Tensor(a!) out) -> Tensor(a!))r1Z_running_with_deployra importlibutil find_specZ_TritonLibraryZ registerOp)rhrjZ has_tritonrrr_register_triton_kernelss(  rn)amp jiteratornvtxprofilersparsetunableZBFloat16TensorZ BoolTensorZ ByteTensorZ CharTensorZ DoubleTensorZ FloatTensorZ HalfTensorZ IntTensorZ LongTensorZ ShortTensorrrrrroZcaching_allocator_allocZcaching_allocator_deleteZ empty_cacheZget_allocator_backendZCUDAPluggableAllocatorZchange_current_allocatorZ get_rng_stateZget_rng_state_allrrgraphsZ initial_seedrrpZlist_gpu_processesrZ manual_seedZmanual_seed_allZmax_memory_allocatedZmax_memory_cachedZmax_memory_reservedZ mem_get_infor.Zmemory_allocatedZ memory_cachedZmemory_reservedZmemory_snapshotZ memory_statsZmemory_stats_as_nested_dictZmemory_summaryZncclrqrrrandomZreset_accumulated_memory_statsZreset_max_memory_allocatedZreset_max_memory_cachedZreset_peak_memory_statsryrxZset_per_process_memory_fractionZ set_rng_stateZset_rng_state_allrsstreamsrt)T)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)r@)r@)r contextlibrkr5sys threadingr|rb functoolsrtypingrrrrrrr r1Ztorch._CZ torch.typesr rr Z_deviceZ_utilsrrrrrurrrrrrwrrrr ImportErrorrulocalrLockrrrrgetattrr2rvrBZ _device_trrr rrerrr{r0r"r#r)r*r+r,r]Z _has_magmar-r. Generatorr3r7r9rGrFrNrTrhrtrwrrLrZOutOfMemoryErrorrrrrr(rrrrrr_r^rDrrrrrrrrrrrr r rrr8rarrArrrrrrrr#r%r$r(r)r*r+r,r/r0r1r2r3r4r5r;r<r.rv staticmethodrCr>Z torch.storagerDrErFrMrQrSrUrVrXrYr[r\r^r_r`Z_storage_classesaddrarnrorprqrrrsrt__all__rrrrs8  $         !7   8 2   "                                          $