U 9%eo@sUdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z mZmZmZddlZddlZddlmZddlmZddlmZd d lmZmZd d lmZmZmZm Z m!Z!d d l"m#Z#m$Z$m%Z%zdd lm&Z&Wne'k rdZ&YnXda(e)Z*e+Z,ga-e.ej/dddZ0eee1e2dfZ3dZ4dZ5zddl6Z6dZ4Wn(e'k rZ7ze7Z5W5dZ7[7XYnXGdddZ8e8a9e:ej/drej/j;Z;nedZ;e:ej/drej/jZ?ne2e2dddZ?dZ@eAeBd<dZCeAeBd<dZDeej/jEeBd <eAd!d"d#ZFeAd!d$d%ZGeAd!d&d'ZHd(d)ZId*d+ZJd,d-ZKd.d/ZLd0d1ZMd2d3ZNeNeKeNeLGd4d5d5eOZPej/jQZRd6d7ZSd8d9ZTd:d;ZUGdd?d?eWZXe2dd@dAdBZYGdCdDdDZZGdEdFdFZGdGdHdHeZ[e3dddIdJZ\dee3e1ddKdLZ]dee3ee2e2fddMdNZ^e3e;ddOdPZ_e3e3eAdQdRdSZ`GdTdUdUZaedVeadWdXdYZbe%dZd[d\Zcee e2e e1fd!d]d^Zde2d!d_d`Zeee e1d!dadbZfe e1e e1e e2dcdddeZge2d!dfdgZheee2efe2ddhdiZie d dje2d!dkdlZje e1d!dmdnZke1d!dodpZle2d!dqdrZmde3dddsdtZndudvZodee3e%ddwdxZpdee3e%ddydzZqd{d|Zree2e1fdd}d~dZse2d!ddZtdeeee2fdddZudeeee2fe2dddZvdeeee2fe2dddZwdeeee2fe2dddZxdeeee2fe2dddZydeeee2fe2dddZzee2e1ejfejdddZ{ejej/jEdddZ|de2ee2e1ejfddddZ}dee2e1ejfe2dddZ~d dlTd dlTeddZGdddZddlmZmZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ[[ejeejeejeejeejeejeejeejeejeejeejeejeGdddZddZeNed dlmZmZmZmZmZdddddddddddddddddddddddd?d5dddddUddddSdBd=d;d|drdxd dzdFdldHdddddndNdLdPdpddddddddd7ddvd'd)dd1ddddddddddddddddddddddddddddddddJdddd\dddYddtdgoZdS(aM This package adds support for CUDA tensor types, that implement 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)AnycastListOptionalTupleUnion)Devicedevice) classproperty) _dummy_type_get_device_index) CUDAGraphgraphgraph_pool_handleis_current_stream_capturingmake_graphed_callables)EventExternalStreamStream)_cudartFZ_cuda_isInBadForkcCsdSNFrrrR/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/torch/cuda/__init__.py-rTc@s2eZdZddZddZddZeddd Zd S) _LazySeedTrackercCsd|_d|_g|_dSNmanual_seed_all_cbmanual_seed_cb call_orderselfrrr__init__?sz_LazySeedTracker.__init__cCs||f|_|j|jg|_dSr r!r&cb tracebackrrrqueue_seed_allDs z_LazySeedTracker.queue_seed_allcCs||f|_|j|jg|_dSr )r#r"r$r(rrr queue_seedIs z_LazySeedTracker.queue_seedreturncCs|jSr )r$r%rrr get_callsNsz_LazySeedTracker.get_callsN)__name__ __module__ __qualname__r'r+r,rr/rrrrr:sr_CudaDeviceProperties_cuda_exchangeDevice)r r.cCs|dkr dStddSNrz)PyTorch was compiled without CUDA support RuntimeErrorr rrr_exchange_device^sr9_cuda_maybeExchangeDevicecCs|dkr dStddSr5r7r rrr_maybe_exchange_devicehsr; has_magmahas_halfrdefault_generatorsr-cCs ttjdS)z*Returns true if compile with CUDA support._cuda_getDeviceCount)hasattrtorch_Crrrr _is_compiledtsrCcCstddkS)NZPYTORCH_NVML_BASED_CUDA_CHECK1)osgetenvrrrr_nvml_based_availysrGcCs,ts dStrtdkStjdkSdS)z9Returns a bool indicating if CUDA is currently available.FrN)rCrG device_countrArBr?rrrr is_available}s  rIcCsTtjjr dStjj}|dk r4t|dddk}nd}tjtjjdkoR|S)zQReturns a bool indicating if the current CUDA/ROCm device supports dtype bfloat16TN.r F) rAversionZhipcudaintsplitget_device_propertiescurrent_devicemajor)Zcu_versZcuda_maj_deciderrris_bf16_supportedsrTcCstj|dSr )rArBZ _cuda_sleep)Zcyclesrrr_sleepsrUc 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|ddVqdS)_rNrOrP.0archrrr sz$_check_capability..#)default) rArMrNrBZ_cuda_getCompiledVersionrangerHget_device_capabilityget_device_namemin get_arch_listwarningswarn) Zincorrect_binary_warnZ old_gpu_warnZ CUDA_VERSIONd capabilityrSminornameZ current_archZmin_archrrr_check_capabilitys(   rjc 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/ rcSs&g|]}d|krt|ddqS)Zsm_rWrrXrYrrr sz!_check_cubins..c3s|]}|dkVqdS)rVNr)rZsmZ cap_majorrrr\sz _check_cubins..rV )rArMrNrclenr_rHr`anyrardreformatjoin)Zincompatible_device_warn arch_listZ supported_smidxZ cap_minor supportedZ device_namergrrmr _check_cubinss*    rvcCs to t S)z:Returns whether PyTorch's CUDA state has been initialized.) _initialized_is_in_bad_forkrrrris_initializedsrycKs`tr|nN|ddr,t|tn0|ddrJt|tnt|tfdS)Nseed_allFseed) ryget_lazy_seed_trackerr+r* format_stackr, _queued_callsappend)callablekwargsrrr _lazy_calls  rc@s eZdZdS)DeferredCudaCallErrorN)r0r1r2rrrrrsrcCs 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: )ryr@_tls_initialization_lockrxr8rArBAssertionErrorrrEenvironZ _cuda_initrr}r/rrdelattr Exceptionstrrrrrw)ZcallsZ queued_callZorig_tracebackemsgrrrr s@        " rcCs ttSr )rrrrrrcudartCsrc@s&eZdZUdZeed<dZeed<dS) cudaStatusrSUCCESS"ERROR_NOT_READYN)r0r1r2rrO__annotations__rrrrrrHs  rcs$eZdZeddfdd ZZS) CudaErrorN)coder.cs,tt|}t|d|ddS)Nz ())rZcudaGetErrorString cudaErrorsuperr')r&rr __class__rrr'NszCudaError.__init__)r0r1r2rOr' __classcell__rrrrrMsr)resr.cCs|tjjkrt|dSr )rrsuccessr)rrrr check_errorSs rc@s4eZdZedddZddZeeedddZd S) _DeviceGuard)indexcCs||_d|_dSNr6)rtprev_idx)r&rrrrr'Ysz_DeviceGuard.__init__cCstj|j|_dSr rArNr9rtrr%rrr __enter__]sz_DeviceGuard.__enter__typevaluer*cCstj|j|_dSrrArNr;rrtr&rrr*rrr__exit__`sz_DeviceGuard.__exit__N)r0r1r2rOr'rrrrrrrrXsrc@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)NToptionalr6)rrtr)r&r rrrr'mszdevice.__init__cCstj|j|_dSr rr%rrrrqszdevice.__enter__rcCstj|j|_dSrrrrrrrtszdevice.__exit__N)r0r1r2__doc__rr'rrrrrrr esr 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')r&objrtrrrr'szdevice_of.__init__)r0r1r2rr'rrrrrrys rcCs t|}|dkrtj|dS)a>Sets 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)rrArBZ_cuda_setDevicer rrr set_devices rcCs t|jS)aGets the name of a device. Args: device (torch.device or int, 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 )rQrir rrrras racCst|}|j|jfS)aGets the cuda capability of a device. Args: device (torch.device or int, 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 )rQrSrh)r proprrrr`s r`cCs4tt|dd}|dks$|tkr,tdt|S)zGets 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)rrrHrZ_get_device_propertiesr rrrrQs  rQ)r peer_devicer.cCs\tt|dd}t|}|dks,|tkr4td|dksF|tkrNtdtj||S)z6Checks if peer access between two devices is possible.TrrrzInvalid peer device id)rrrHrrArBZ_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)NTr6) rrrtrAZjitZ is_scriptingrNdefault_streamsrc_prev_streamdst_prev_stream)r&rrrrr's   zStreamContext.__init__c Csn|j}|dks|jdkrdStjd|_|jj|jkr^t|jtj|j|_W5QRXtj|dSr) rrtrArNcurrent_streamrr r set_stream)r&rrrrrs zStreamContext.__enter__rcCsJ|j}|dks|jdkrdS|jj|jkr8tj|jtj|jdSr)rrtrr rArNrr)r&rrr*rrrrrs zStreamContext.__exit__N) r0r1r2rrrr'rrrrrrrrs  rr)rr.cCst|S)aTWrapper 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``. )rrrrrr s rrcCs(|dkr dStjj|j|j|jddS)aSets 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``. N stream_id device_index device_type)rArBZ_cuda_setStreamrrrrrrrrs rcCstd}|dkrttdSttddd}ttttddd }|d rX||d S|d rl||d Sg}|d D]@}|| }||krt ttgS|d krq| |qz|S)z0Parse CUDA_VISIBLE_DEVICES environment variable.ZCUDA_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,r6rz+-rN) enumerateisdigitrorO)rrtcrrr_strtoul1s z(_parse_visible_devices.._strtoul)lstprefixr.cSsJg}|dD]6}||kr,tttgS||s:qF||q|S)N,)rPrrr startswithr)rrrcselemrrrparse_list_with_prefix<s  z6_parse_visible_devices..parse_list_with_prefixzGPU-MIG-rr) rErFlistr_rrOrrrPstriprr)varrrrcrxrrr_parse_visible_devices+s$         rcCsnddlm}m}m}|d}|}|dkr:tddS|d}|||}|dkrftddS~|jS)zkReturn number of devices as reported by NVML or negative value if NVML discovery/initialization failed.r)byrefc_intCDLLlibnvidia-ml.so.1Can't initialize NVMLr6Can't get nvml device count) ctypesrrrnvmlInitrdrenvmlDeviceGetCount_v2r)rrrnvml_hr dev_countrrr_raw_device_count_nvml[s  rc Csddlm}m}m}m}m}|d}|}|dkrBtddS|d}| ||}|dkrntddSg}t |j D]|} |} | | || }|dkrtddSd } || } | | | | }|dkrtd dS|| jd d q|~|S) zbReturn list of device UUID as reported by NVML or None if NVM discovery/initialization failed.r)rrc_void_prcreate_string_bufferrrNr6rzCan't get device handle`zCan't get device UUIDascii)rrrrrrrrdrerr_rZnvmlDeviceGetHandleByIndex_v2ZnvmlDeviceGetUUIDrrawdecoder) rrrrrrrruuidsrtZdev_idbuf_lenbufrrr_raw_device_uuid_nvmlns6    r) candidatesrr.cCsbttttddd}g}|D]>}|||}|dkr8q^||krRtttgS||q|S)ztGiven 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_matchrtuuidrrruuid_to_orinals z3_transform_uuid_to_ordinals..uuid_to_orinalr)rrrOrr)rrrrrrtrrr_transform_uuid_to_ordinalss   rcCst}|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.rrr6N)rrrrrrrrrrrOOSErrorAttributeErrorro)visible_devicesrZraw_cntrtvalrrr_device_count_nvmls2 rcCst|dd}t}t|dtkrLt}|dkr8tdtttt||}t t ttt |}||krtd|d|d||S) zOReturns the NVML index of the device, taking CUDA_VISIBLE_DEVICES into account.TrrNzCan't get device UUIDszdevice z& is not visible (CUDA_VISIBLE_DEVICES=r) rrrrrr8rrrdictrrO)r rtrrZidx_maprrr_get_nvml_device_indexs   r)maxsizecCs&ts dSt}|dkr"tjS|S)z%Returns the number of GPUs available.r)rCrrArBr?)Z nvml_countrrrrHsrHcCs(ts gStj}|dkr gS|S)z>Returns list CUDA architectures this library was compiled for.N)rIrArBZ_cuda_getArchFlagsrP)Z arch_flagsrrrrcs  rccCs8t}t|dkrdSdd|D}ddd|DS)z:Returns NVCC gencode flags this library was compiled with.rrcSsg|]}|dqS)rW)rPrYrrrrksz%get_gencode_flags..rncSs&g|]\}}d|d|d|qS)z-gencode compute=compute_z,code=rWr)rZkindr[rrrrks)rcrorr)rsZ arch_list_rrrget_gencode_flagss rcCsttjS)z1Returns the index of a currently selected device.)rrArBZ_cuda_getDevicerrrrrRsrRc Cs4ttj|tjW5QRSQRXdS)a-Waits 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)rrArNr rBZ_cuda_synchronizer rrr synchronizesrcCsttjS)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. )rrArBZ_cuda_ipc_collectrrrr ipc_collects rcCs4ttjt|dd}t|d|d|ddS)aTReturns 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)rrArBZ_cuda_getCurrentStreamrrr Z streamdatarrrrs  rcCs4ttjt|dd}t|d|d|ddS)a>Returns 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)rrArBZ_cuda_getDefaultStreamrrrrrrr1s  rcCsttjS)z7Returns cublasHandle_t pointer to current cuBLAS handle)rrArBZ_cuda_getCurrentBlasHandlerrrrcurrent_blas_handleCsr) debug_moder.cCsRtt|trB|dkrd}n$|dkr,d}n|dkr:d}ntdtj|dS) aSets 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^rrererrorr zGinvalid value of debug_mode, expected one of `default`, `warn`, `error`N)r isinstancerr8rArBZ_cuda_set_sync_debug_mode)rrrrset_sync_debug_modeIs  r cCsttjS)zFReturns current value of debug mode for cuda synchronizing operations.)rrArBZ_cuda_get_sync_debug_moderrrrget_sync_debug_modeesr c 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?) _HAS_PYNVMLModuleNotFoundError _PYNVML_ERRpynvmlr rr8rnvmlDeviceGetHandleByIndex)r r rhandlerrr_get_pynvml_handlerls   rcCs$t}t|}t|}t|jS)aReturns 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. )rrrrnvmlDeviceGetUtilizationRatesmemoryr rrrr memory_usage}s  rcCs&t|}t|}t|}t|jS)aReturns 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. )rrrrrZgpurrrr utilizations  rcCst|}t|dS)aReturns the average temperature of the GPU sensor in Degrees C (Centigrades) 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. r)rrZnvmlDeviceGetTemperaturerrrr temperatures rcCst|}t|S)a Returns 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. )rrZnvmlDeviceGetPowerUsagerrrr power_draws rcCst|}t|dS)aReturns 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. r)rrZnvmlDeviceGetClockInforrrr clock_rates rcCs0t|trt|}nt|tr,td|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int): selected device. rN)r rrAr rOr rrr _get_devices     rcCs |j}|dkrt}tjj|S)zvReturn the CUDA Generator object for the given device. Args: device (torch.device): selected device. N)rrRrArNr>)r rtrrr_get_generatorsrrN)offsetr r.cs"t|fdd}t|dS)a(Sets 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}|dSr )rZ set_offset)default_generator final_devicerrrr)sz!_set_rng_state_offset..cbN)rr)rr r)rr!r_set_rng_state_offsets r#cCstt|}t|}|S)aQReturns 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. )rrrZ get_offset)r r"r rrr_get_rng_state_offsets r$)*cOsttt|j|f||Sr )rr _CudaBase__new__clsargsrrrr _lazy_newsr+cs(eZdZdZdZfddZeZZS)r&TFc s2t|tj||W5QRSQRXdSr )r rrr)r&r*rrrrr&sz_CudaBase.type) r0r1r2rZ is_sparserr+r'rrrrrr&"s r&)_LegacyStorage_warn_typed_storage_removalc@s8eZdZeddZeddZedddddZdS) _CudaLegacyStoragecOsttddS)Nz+from_buffer: Not available for CUDA storage)r-r8r(rrr from_buffer4sz_CudaLegacyStorage.from_buffercOs tddS)Nz2_new_with_weak_ptr: Not available for CUDA storager7r(rrr_new_with_weak_ptr9sz%_CudaLegacyStorage._new_with_weak_ptrN)r dtypecCs tddS)Nz4_new_shared_filename: Not available for CUDA storager7)r)managerrsizer r1rrr_new_shared_filename=sz'_CudaLegacyStorage._new_shared_filename)r0r1r2 classmethodr/r0r4rrrrr.3s   r.c@s$eZdZeddZeddZdS) ByteStoragecCs t|jSr r-_dtyper%rrrr1CszByteStorage.dtypecCstjSr )rAZuint8r%rrrr8HszByteStorage._dtypeNr0r1r2r r1r8rrrrr6Bs r6c@s$eZdZeddZeddZdS) DoubleStoragecCs t|jSr r7r%rrrr1NszDoubleStorage.dtypecCstjSr )rAdoubler%rrrr8SszDoubleStorage._dtypeNr9rrrrr:Ms r:c@s$eZdZeddZeddZdS) FloatStoragecCs t|jSr r7r%rrrr1YszFloatStorage.dtypecCstjSr )rAfloatr%rrrr8^szFloatStorage._dtypeNr9rrrrr<Xs r<c@s$eZdZeddZeddZdS) HalfStoragecCs t|jSr r7r%rrrr1dszHalfStorage.dtypecCstjSr )rAZhalfr%rrrr8iszHalfStorage._dtypeNr9rrrrr>cs r>c@s$eZdZeddZeddZdS) LongStoragecCs t|jSr r7r%rrrr1oszLongStorage.dtypecCstjSr )rAlongr%rrrr8tszLongStorage._dtypeNr9rrrrr?ns r?c@s$eZdZeddZeddZdS) IntStoragecCs t|jSr r7r%rrrr1zszIntStorage.dtypecCstjSr )rArOr%rrrr8szIntStorage._dtypeNr9rrrrrAys rAc@s$eZdZeddZeddZdS) ShortStoragecCs t|jSr r7r%rrrr1szShortStorage.dtypecCstjSr )rAshortr%rrrr8szShortStorage._dtypeNr9rrrrrBs rBc@s$eZdZeddZeddZdS) CharStoragecCs t|jSr r7r%rrrr1szCharStorage.dtypecCstjSr )rAZint8r%rrrr8szCharStorage._dtypeNr9rrrrrDs rDc@s$eZdZeddZeddZdS) BoolStoragecCs t|jSr r7r%rrrr1szBoolStorage.dtypecCstjSr )rAboolr%rrrr8szBoolStorage._dtypeNr9rrrrrEs rEc@s$eZdZeddZeddZdS)BFloat16StoragecCs t|jSr r7r%rrrr1szBFloat16Storage.dtypecCstjSr )rAZbfloat16r%rrrr8szBFloat16Storage._dtypeNr9rrrrrGs rGc@s$eZdZeddZeddZdS)ComplexDoubleStoragecCs t|jSr r7r%rrrr1szComplexDoubleStorage.dtypecCstjSr )rAZcdoubler%rrrr8szComplexDoubleStorage._dtypeNr9rrrrrHs rHc@s$eZdZeddZeddZdS)ComplexFloatStoragecCs t|jSr r7r%rrrr1szComplexFloatStorage.dtypecCstjSr )rAZcfloatr%rrrr8szComplexFloatStorage._dtypeNr9rrrrrIs rIc@s eZdZdZddZddZdS)_WrappedTritonKernelzBJust a simple wrapper to store some metadata for testing purposes.cCs||_d|_dSrkernelZkernel_invoked)r&rLrrrr'sz_WrappedTritonKernel.__init__cOs|j||}d|_|S)NTrK)r&r*rrrrr__call__s z_WrappedTritonKernel.__call__N)r0r1r2rr'rMrrrrrJsrJcCsBtr dStdd}tjddk }|r>tjdd|ddS)Nc_sddlm}||ddi|S)Nr) bsr_dense_mmZ skip_checksT)Ztorch.sparse._triton_opsrN)r*rrNrrr kernel_impls z-_register_triton_kernels..kernel_implZtritonZ_triton_bsr_dense_mm_outzS_triton_bsr_dense_mm_out(Tensor bsr, Tensor dense, *, Tensor(a!) out) -> Tensor(a!)Z SparseCsrCUDA)rAZ_running_with_deployrJ importlibutil find_specZ_TritonLibraryZ registerOp)rOZ has_tritonrrr_register_triton_kernelss rS)amp jiteratornvtxprofilersparseZBFloat16TensorZ BoolTensorZ ByteTensorZ CharTensorZ DoubleTensorZ FloatTensorZ HalfTensorZ IntTensorZ LongTensorZ ShortTensorrrrOutOfMemoryErrorrrTZcaching_allocator_allocZcaching_allocator_deleteZ empty_cacheZget_allocator_backendZCUDAPluggableAllocatorZchange_current_allocatorZ get_rng_stateZget_rng_state_allrrgraphsZ initial_seedrrUZlist_gpu_processesrZ manual_seedZmanual_seed_allZmax_memory_allocatedZmax_memory_cachedZmax_memory_reservedZ mem_get_inforZmemory_allocatedZ memory_cachedZmemory_reservedZmemory_snapshotZ memory_statsZmemory_stats_as_nested_dictZmemory_summaryZncclrVrWrandomZreset_accumulated_memory_statsZreset_max_memory_allocatedZreset_max_memory_cachedZreset_peak_memory_statsr{rzZset_per_process_memory_fractionZ set_rng_stateZset_rng_state_allrXstreams)N)N)N)N)N)N)N)N)N)N)N)rN)rN)r contextlibrPrEsys threadingr*rd functoolsrtypingrrrrrrrAZtorch._CZ torch.typesr rr Z_device_utilsr rrrZrrrrrr\rrrr ImportErrorrwlocalrLockrrgetattrrBrxrrOZ _device_trrrerrrr}r@r3r4r9r:r;r<rFrr=r> GeneratorrCrGrIrTrUrjrvryrrrZ_OutOfMemoryErrorrYrrrrr8rrrrrrar`rQrrrrrrrrrrrHrcrrRrrrrrr r rrrrrrrrr#r$rr[ staticmethodr+r&Z torch.storager,r-r.r6r:r<r>r?rArBrDrErGrHrIZ_storage_classesaddrJrSrTrUrVrWrX__all__rrrrs            ! 7  8 0!