o ,’×ik<ã@sPUdZddlZddlZddlmZddlmZmZmZm Z m Z mZmZddl Z ddlZ ddlmZddlmZmZdd lmZdd lmZmZdae ¡Ze ¡Zgae eegdfe efe d<e!e j"d dd„ƒZ#eeee$dfZ%eƒa&dZ'ee j"j(e d<de)fdd„Z*e*ƒr˜e j"j+Z+e j"j,Z-e j"j.Z/nedƒZ+de$de$fdd„Z-de$de$fdd„Z/eddde$fdd„ƒZ0de)fdd„Z1d d!„Z2d"d#„Z3d$d%„Z4d&d'„Z5d(d)„Z6Gd*d+„d+ƒZ7Gd,d„dƒZGd-d.„d.eƒZ8de%ddfd/d0„Z9dTde e%defd1d2„Z:edƒdTde e%deeeffd3d4„ƒZ;dTde e%de+fd5d6„ZGd;d<„d<ƒZ?d=e d>de?fd?d=„Z@d@dA„ZAd=efdBdC„ZBdTde e%defdDdE„ZCdTde%ddfdFdG„ZDdUdHdI„ZEde jde j"j(fdJdK„ZF LdVdMe$dee$ee jfddfdNdO„ZGdVdee$ee jfde$fdPdQ„ZHddRlITgdS¢ZJdS)Wzó This package introduces support for the XPU backend, specifically tailored for Intel GPU optimization. This package is lazily initialized, so you can always import it, and use :func:`is_available()` to determine if your system supports XPU. éN)Ú lru_cache)ÚAnyÚCallableÚDictÚListÚOptionalÚTupleÚUnioné©Údevice)Ú_dummy_typeÚ_LazySeedTrackeré)Ú_get_device_index)ÚEventÚStreamFÚ _queued_callsÚ_xpu_isInBadForkcCódS©NF©rrrúP/home/ubuntu/SoloSpeech/.venv/lib/python3.10/site-packages/torch/xpu/__init__.pyÚsrrÚdefault_generatorsÚreturncCstjjS)z(Return true if compile with XPU support.)ÚtorchÚ_CÚ_has_xpurrrrÚ_is_compiled!srÚ_XpuDevicePropertiesrcCótdƒ‚©Nz(PyTorch was compiled without XPU support©ÚNotImplementedErrorrrrrÚ_exchange_device.ór%cCr!r"r#rrrrÚ_maybe_exchange_device1r&r')ÚmaxsizecCstƒsdStj ¡S)z*Return the number of XPU device available.r)rrrÚ_xpu_getDeviceCountrrrrÚdevice_count5s r*cCs tƒdkS)z7Return a bool indicating if XPU is currently available.r)r*rrrrÚis_available=s r+cCr)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.TrrrrrÚis_bf16_supportedCsr,cCstotƒS)z8Return whether PyTorch's XPU state has been initialized.)Ú_initializedÚ_is_in_bad_forkrrrrÚis_initializedHsr/cKsftƒr|ƒdS| dd¡rt |t ¡¡dS| dd¡r(t |t ¡¡dSt |t ¡f¡dS)NÚseed_allFÚseed) r/ÚgetÚ_lazy_seed_trackerÚqueue_seed_allÚ tracebackÚformat_stackÚ queue_seedrÚappend)ÚcallableÚkwargsrrrÚ _lazy_callMs r;cCs tƒdS)z×Initialize PyTorch's XPU state. This is a Python API about lazy initialization that avoids initializing XPU until the first time it is accessed. Does nothing if the XPU state is already initialized. N)Ú _lazy_initrrrrÚinit[s r=cCstƒsttdƒr dStstƒr WdƒdStƒr tdƒ‚tƒs'tdƒ‚tj ¡dt_t ¡D] }|rr3Ú get_callsrr8Ú ExceptionÚstrÚjoinÚdelattrr-)ÚcallsÚqueued_callÚorig_tracebackÚeÚmsgrrrr<dsDüÿ € ÿÿ €ûý "Ýr<c@s8eZdZdefdd„Zdd„Zdededefd d „ZdS)Ú_DeviceGuardÚindexcCs||_d|_dS©Néÿÿÿÿ)ÚidxÚprev_idx)ÚselfrQrrrÚ__init__s z_DeviceGuard.__init__cCótj |j¡|_dS©N©rÚxpur%rTrU©rVrrrÚ __enter__“óz_DeviceGuard.__enter__ÚtypeÚvaluer5cCótj |j¡|_dSr©rr[r'rUrT©rVr_r`r5rrrÚ__exit__–óz_DeviceGuard.__exit__N)Ú__name__Ú __module__Ú__qualname__ÚintrWr]rrdrrrrrPŽsrPc@s<eZdZdZdefdd„Zdd„Zdededefd d „ZdS)rzÓContext-manager that changes the selected device. Args: device (torch.device or int or str): device index to select. It's a no-op if this argument is a negative integer or ``None``. cCst|dd|_d|_dS)NT©ÚoptionalrS)rrTrU)rVrrrrrW£s zdevice.__init__cCrXrYrZr\rrrr]§r^zdevice.__enter__r_r`r5cCrarrbrcrrrrdªrezdevice.__exit__N)rfrgrhÚ__doc__rrWr]rdrrrrr›s cs eZdZdZ‡fdd„Z‡ZS)Ú 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 XPU, this is a no-op. Args: obj (Tensor or Storage): object allocated on the selected device. cs"|jr| ¡nd}tƒ |¡dSrR)Úis_xpuÚ get_deviceÚsuperrW)rVÚobjrT©Ú __class__rrrW¹szdevice_of.__init__)rfrgrhrlrWÚ __classcell__rrrrrrm¯s rmcCs*tƒt|ƒ}|dkrtj |¡dSdS)z¨Set the current device. Args: device (torch.device or int or str): selected device. This function is a no-op if this argument is negative. rN)r<rrrÚ_xpu_setDevicerrrrÚ set_device¾s ÿrvcCs 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.xpu.current_device`, if :attr:`device` is ``None`` (default). Returns: str: the name of the device )Úget_device_propertiesÚnamerrrrÚget_device_nameËs rycst|ƒ‰‡fdd„tˆƒDƒS)aÐGet the xpu 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.xpu.current_device`, if :attr:`device` is ``None`` (default). Returns: Dict[str, Any]: the xpu capability dictionary of the device cs"i|] }| d¡s|tˆ|ƒ“qS)Ú__)Ú startswithÚgetattr)Ú.0Úprop©ÚpropsrrÚ és ÿ ÿz)get_device_capability..)rwÚdirrrrrÚget_device_capabilityÚs ÿrƒcCs4tƒt|dd}|dks|tƒkrtdƒ‚t|ƒS)zêGet the properties of a device. Args: device (torch.device or int or str): device for which to return the properties of the device. Returns: _XpuDeviceProperties: the properties of the device TrjrzInvalid device index)r<rr*rDÚ_get_device_propertiesrrrrrwîs rwcCstƒtj ¡S)z0Return the index of a currently selected device.)r<rrÚ_xpu_getDevicerrrrÚcurrent_deviceÿs r†cCs2t|tƒrt |¡}|St|tƒrt d|¡}|S)zŒReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r[)Ú isinstancerHrrrirrrrÚ_get_devices þrˆc@sNeZdZUdZeded<dedfdd„Zdd„Zd ed edefdd „Z dS)Ú StreamContextaContext-manager that selects a given stream. All XPU 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.xpu.StreamÚ cur_streamÚstreamcCs*||_tddƒ|_|jdurd|_dSdS)NTrS)rŒrrT)rVrŒrrrrWs ÿzStreamContext.__init__cCs‚|j}|dus|jdkrdStj d¡|_|jj|jkr9t|jƒtj |j¡|_Wdƒn1s4wYtj |¡dSrR) rŒrTrr[Úcurrent_streamÚsrc_prev_streamrÚdst_prev_streamÚ set_stream)rVr‹rrrr]%sÿzStreamContext.__enter__r_r`r5cCsJ|j}|dus|jdkrdS|jj|jkrtj |j¡tj |j¡dSrR)rŒrTrŽrrr[rr)rVr_r`r5r‹rrrrd1szStreamContext.__exit__N) rfrgrhrlrÚ__annotations__rWr]rrdrrrrr‰s r‰rŒrŠcCst|ƒS)z³Wrap 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``. )r‰©rŒrrrrŒ<scCstjj|||ddS)aset stream specified by the stream id, device index and device type Args: stream_id (int): not visible to the user, used to assigned to the specific stream. device_index (int): selected device index. device_type (int): selected device type. ©Ú stream_idÚdevice_indexÚdevice_typeN)rrÚ_xpu_setStreamr“rrrÚ_set_stream_by_idEs ýr˜cCs*|durdStƒt|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“)r<r˜r”r•r–r’rrrrSs ýrcCs4tƒtj t|dd¡}t|d|d|ddS)aRReturn 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.xpu.current_device`, if :attr:`device` is ``None`` (default). Trjrrr r“)r<rrÚ_xpu_getCurrentStreamrr)rÚ streamdatarrrrfs ÿÿrcCstƒt|dd}tj |¡S)a*Wait for all kernels in all streams on a XPU device to complete. Args: device (torch.device or int, optional): device for which to synchronize. It uses the current device, given by :func:`~torch.xpu.current_device`, if :attr:`device` is ``None`` (default). Trj)r<rrrÚ_xpu_synchronizerrrrÚsynchronizexsrœcCstƒr tj ¡dSdS)aZRelease all unoccupied cached memory currently held by the caching allocator so that those can be used in other XPU application. .. note:: :func:`~torch.xpu.empty_cache` doesn't increase the amount of XPU memory available for PyTorch. However, it may help reduce fragmentation of XPU memory in certain cases. N)r/rrÚ_xpu_emptyCacherrrrÚempty_cache…s ÿržcCs |j}|dur tƒ}tjj|S)zuReturn the XPU Generator object for the given device. Args: device (torch.device): selected device. N)rQr†rr[r)rrTrrrÚ_get_generator’srŸr[Úoffsetcs"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: ``'xpu'`` (i.e., ``torch.device('xpu')``, the current XPU device). cstˆƒ}| ˆ¡dSrY)rŸÚ set_offset)Údefault_generator©Úfinal_devicer rrÚcbªsz!_set_rng_state_offset..cbN)rˆr;)r rr¥rr£rÚ_set_rng_state_offsetžs r¦cCstƒt|ƒ}t|ƒ}| ¡S)aLReturn 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: ``'xpu'`` (i.e., ``torch.device('xpu')``, the current XPU device). .. warning:: This function eagerly initializes XPU. )r<rˆrŸÚ get_offset)rr¤r¢rrrÚ_get_rng_state_offset±s r¨)Ú*) rrr‰r†rrrrmr*ržrƒryrwÚ get_rng_stateÚget_rng_state_allÚ get_streamr=Úinitial_seedr+r,r/Úmanual_seedÚmanual_seed_allr1r0rvÚ set_rng_stateÚset_rng_state_allrrŒÚstreamsrœrY)rN)r[)KrlÚ threadingr5Ú functoolsrÚtypingrrrrrrr rÚtorch._Cr?rÚ_deviceÚ_utilsr rrr²rrr-ÚlocalrAÚLockrBrrHr‘r|rr.riÚ _device_tr3rÚ GeneratorÚboolrr Ú_xpu_exchangeDevicer%Ú_xpu_maybeExchangeDevicer'r*r+r,r/r;r=r<rPrmrvryrƒrwr†rˆr‰rŒr˜rrrœržrŸr¦r¨ÚrandomÚ__all__rrrrÚs†$þÿ * " * ÿÿÿ þ