a hF@sUdZddlZddlZddlmZddlmZmZmZm Z ddl Z ddl Z ddl m Z ddlmZmZddlmZdd lmZmZd aeZeZgaeeegdfeefed <e e j!d d dZ"e e ee#dfZ$ea%dZ&ee j!j'ed<e(dddZ)e)r&e j!j*Z*e j!j+Z,e j!j-Z.n(edZ*e#e#dddZ,e#e#dddZ.edde#dddZ/e(dddZ0d^e(e(d d!d"Z1d#d$Z2d%d&Z3d'd(Z4d)d*Z5Gd+d,d,Z6Gd-d.d.Z Gd/d0d0e Z7e$ddd1d2Z8d_ee$edd3d4Z9edd`ee$e:eefdd5d6Z;daee$e*dd7d8ZGd=d>d>Z?ed?e?d@dAdBZ@dCdDZAedEdFdGZBdbee$eddHdIZCdce#ee$edJdKdLZDdde$dddMdNZEeeddOdPZFeddQdRZGe j e j!j'ddSdTZHdee#e e#ee j fddVdWdXZIdfe e#ee j fe#ddYdZZJdd[lKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUdd\lVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_gd]Z`dS)gz 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)AnyCallableOptionalUniondevice) _dummy_type_LazySeedTracker)_get_device_index)EventStreamF _queued_callsZ_xpu_isInBadForkcCsdSNFrrr@/var/www/auris/lib/python3.9/site-packages/torch/xpu/__init__.pyrrdefault_generators)returncCstjjS)z(Return true if compile with XPU support.)torch_CZ_has_xpurrrr _is_compiled#sr_XpuDeviceProperties)rrcCs tddSNz(PyTorch was compiled without XPU supportNotImplementedErrorrrrr_exchange_device0srcCs tddSrrrrrr_maybe_exchange_device3sr)maxsizecCsts dStjS)z*Return the number of XPU device available.r)rrrZ_xpu_getDeviceCountrrrr device_count7sr!cCs tdkS)z7Return a bool indicating if XPU is currently available.r)r!rrrr is_available?sr"T)including_emulationrcCsts dS|ptjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r"rxpuget_device_propertiesZhas_bfloat16_conversions)r#rrris_bf16_supportedEs  r&cCs to t S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrrris_initializedOsr)cKs`tr|nN|ddr,t|tn0|ddrJt|tnt|tfdS)Nseed_allFseed) r)get_lazy_seed_trackerZqueue_seed_all traceback format_stackZ queue_seedrappend)callablekwargsrrr _lazy_callTs  r3cCs tdS)zInitialize 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_initrrrrinitbsr5c CststtdrdSttr0WddStr>tdtsLtdtj dt_ t ddtDzpt D]\\}}z |Wqzty}z0dt|dd |}t||WYd}~qzd}~00qzWttdn ttd0daWdn1s 0YdS) Nis_initializingzuCannot re-initialize XPU in forked subprocess. To use XPU with multiprocessing, you must use the 'spawn' start methodz#Torch not compiled with XPU enabledTcss|]}|r|VqdSNr).0Zcallsrrr rz_lazy_init..z5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )r)hasattr_tls_initialization_lockr( RuntimeErrorrAssertionErrorrrZ _xpu_initr6rextendr-Z get_calls Exceptionstrjoindelattrr')Z queued_callZorig_tracebackemsgrrrr4ks4    $r4c@s4eZdZedddZddZeeedddZd S) _DeviceGuard)indexcCs||_d|_dSN)idxprev_idx)selfrHrrr__init__sz_DeviceGuard.__init__cCstj|j|_dSr7rr$rrKrLrMrrr __enter__sz_DeviceGuard.__enter__typevaluer.cCstj|j|_dSrrr$rrLrKrMrSrTr.rrr__exit__sz_DeviceGuard.__exit__N)__name__ __module__ __qualname__intrNrQrrWrrrrrGsrGc@s8eZdZdZedddZddZeeeddd Zd S) rzContext-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``. rcCst|dd|_d|_dS)NToptionalrJ)r rKrL)rMrrrrrNszdevice.__init__cCstj|j|_dSr7rOrPrrrrQszdevice.__enter__rRcCstj|j|_dSrrUrVrrrrWszdevice.__exit__N)rXrYrZ__doc__rrNrQrWrrrrrsrcs 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 XPU, this is a no-op. Args: obj (Tensor or Storage): object allocated on the selected device. cs"|jr|nd}t|dSrI)Zis_xpuZ get_devicesuperrN)rMobjrK __class__rrrNszdevice_of.__init__)rXrYrZr^rN __classcell__rrrbrr_s r_cCs&tt|}|dkr"tj|dS)zSet 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)r4r rrZ_xpu_setDevicerrrr set_devicesrecCs 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 )r%namerrrrget_device_names rgcst|fddtDS)aGet 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|]}|ds|t|qS))__Z _pybind11_) startswithgetattr)r8proppropsrr s z)get_device_capability..)r%dirrrrlrget_device_capabilitys rpcCstt|dd}t|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: _XpuDeviceProperties: the properties of the device Tr\)r4r Z_get_device_propertiesrrrrr%s  r%cCsttjS)z0Return the index of a currently selected device.)r4rrZ_xpu_getDevicerrrrcurrent_device srqcCs0t|trt|}nt|tr,td|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r$) isinstancerBrrr[rrrr _get_devices     rsc@sJeZdZUdZeded<eddddZddZeeed d d Z d S) 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_streamstreamcCs&||_tdd|_|jdur"d|_dS)NTrJ)rxr rK)rMrxrrrrN)s  zStreamContext.__init__cCs|j}|dus|jdkrdStjd|_|jj|jkrrt|j tj|j|_Wdn1sh0Ytj|dSrI) rxrKrr$current_streamsrc_prev_streamrdst_prev_stream set_stream)rMrvrrrrQ/s .zStreamContext.__enter__rRcCsJ|j}|dus|jdkrdS|jj|jkr8tj|jtj|jdSrI)rxrKrzrrr$r|r{)rMrSrTr.rvrrrrW;s zStreamContext.__exit__N) rXrYrZr^r__annotations__rNrQrrWrrrrrts   rtru)rxrcCst|S)zWrap 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``. )rtrwrrrrxFsrxcCstjj|||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)rrZ_xpu_setStreamr~rrr_set_stream_by_idOs rrwcCs*|dur dStt|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~)r4rrrrrwrrrr|]s r|cCs4ttjt|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). Tr\rr r~)r4rrZ_xpu_getCurrentStreamr r)r streamdatarrrryps  ry)data_ptrrrcCs6ttj|t|dd}t|d|d|ddS)a;Return a :class:`Stream` from an external SYCL queue. This function is used to wrap SYCL queue created in other libraries in order to facilitate data exchange and multi-library interactions. .. note:: This function doesn't manage the queue life-cycle, it is the user responsibility to keep the referenced queue alive while this returned stream is being used. The different SYCL queue pointers will result in distinct :class:`Stream` objects, even if the SYCL queues they dereference are equivalent. Args: data_ptr(int): Integer representation of the `sycl::queue*` value passed externally. device(torch.device or int, optional): the device where the queue was originally created. It is the user responsibility to ensure the device is specified correctly. Tr\rr rr~)r4rrZ_xpu_getStreamFromExternalr r)rrrrrrget_stream_from_externals rcCstt|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). Tr\)r4r rrZ_xpu_synchronizerrrr synchronizes rcCs(ts gStj}|dur gS|S)z.)rlenrC)Z arch_listrrrget_gencode_flagss rcCs |j}|durt}tjj|S)zuReturn the XPU Generator object for the given device. Args: device (torch.device): selected device. N)rHrqrr$r)rrKrrr_get_generatorsrr$)offsetrrcs"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}|dSr7)rZ set_offset)default_generator final_devicerrrcbsz!_set_rng_state_offset..cbN)rsr3)rrrrrr_set_rng_state_offsets rcCstt|}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. )r4rsrZ get_offset)rrrrrr_get_rng_state_offsets r) empty_cachemax_memory_allocatedmax_memory_reserved mem_get_infomemory_allocatedmemory_reserved memory_statsmemory_stats_as_nested_dictreset_accumulated_memory_statsreset_peak_memory_stats) get_rng_stateget_rng_state_all initial_seed manual_seedmanual_seed_allr+r* set_rng_stateset_rng_state_all)+r rrtrqryrrr_r!rrrprgr%rrrrr5rr"r&r)rrrrrrrrrrrr+r*rerrr|rxstreamsr)T)N)N)N)N)N)N)r$)r$)ar^ threadingr. functoolsrtypingrrrrrZtorch._CrZ_deviceZ torch._utilsr r _utilsr rr rr'localr<Lockr=rlisttuplerBr}rjrr(r[Z _device_tr-r GeneratorboolrrZ_xpu_exchangeDevicerZ_xpu_maybeExchangeDevicerr!r"r&r)r3r5r4rGr_rergdictrpr%rqrsrtrxrr|ryrrrrrrrZmemoryrrrrrrrrrrrandomrrrrrr+r*rr__all__rrrrs      (    *      0 ,