
    JThVE                        % S r SSKrSSKrSSKJr  SSKJrJrJrJ	r	  SSK
r
SSKr
SSK
Jr  SSKJrJr  SSKJr  SS	KJrJr  S
q\R.                  " 5       r\R2                  " 5       r/ q\\\/ S4   \\   4      \S'   \ " \
RB                  SS 5      r"\	\\\#S4   r$\" 5       q%Sr&\\
RB                  RN                     \S'   S\(4S jr)\)" 5       (       aC  \
RB                  RT                  r*\
RB                  RV                  r,\
RB                  RZ                  r.O\" S5      r*S\#S\#4S jr,S\#S\#4S jr.\" SS9S\#4S j5       r/S\(4S jr0S r1S r2S r3S r4S r5 " S S5      r6 " S  S5      r " S! S"\5      r7S\$SS4S# jr8S=S\\$   S\4S$ jjr9\" S5      S=S\\$   S\:\\4   4S% jj5       r;S=S\\$   S\*4S& jjr<S\#4S' jr=S\	\#\\
R                  4   S\
R                  4S( jr> " S) S*5      r?S+\S,   S\?4S- jr@S. rAS+\4S/ jrBS=S\\$   S\4S0 jjrC S=S1\#S\\$   S\4S2 jjrDS=S\$SS4S3 jjrES\\   4S4 jrFS\4S5 jrGS\
R                  S\
RB                  RN                  4S6 jrH S>S7\#S\	\#\\
R                  4   SS4S8 jjrIS>S\	\#\\
R                  4   S\#4S9 jjrJSS:KKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrTJUrU  SS;KVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_  / S<Qr`g)?z
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OptionalUniondevice)_dummy_type_LazySeedTracker   )_get_device_index)EventStreamF_queued_calls_xpu_isInBadForkc                      gNF r       J/var/www/auris/envauris/lib/python3.13/site-packages/torch/xpu/__init__.py<lambda>r      s    r   r   default_generatorsreturnc                  6    [         R                  R                  $ )z(Return true if compile with XPU support.)torch_C_has_xpur   r   r   _is_compiledr   #   s    88r   _XpuDevicePropertiesr	   c                     [        S5      eNz(PyTorch was compiled without XPU supportNotImplementedErrorr   s    r   _exchange_devicer$   0       !"LMMr   c                     [        S5      er!   r"   r   s    r   _maybe_exchange_devicer'   3   r%   r   )maxsizec                  ^    [        5       (       d  g[        R                  R                  5       $ )z*Return the number of XPU device available.r   )r   r   r   _xpu_getDeviceCountr   r   r   device_countr+   7   s!     >>88''))r   c                      [        5       S:  $ )z7Return a bool indicating if XPU is currently available.r   )r+   r   r   r   is_availabler-   ?   s     >Ar   c                      g)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.Tr   r   r   r   is_bf16_supportedr/   E   s    r   c                  :    [         =(       a    [        5       (       + $ )z8Return whether PyTorch's XPU state has been initialized.)_initialized_is_in_bad_forkr   r   r   is_initializedr3   J   s    1 111r   c                    [        5       (       a  U " 5         g UR                  SS5      (       a*  [        R                  U [        R
                  " 5       5        g UR                  SS5      (       a*  [        R                  U [        R
                  " 5       5        g [        R                  U [        R
                  " 5       45        g )Nseed_allFseed)	r3   get_lazy_seed_trackerqueue_seed_all	tracebackformat_stack
queue_seedr   append)callablekwargss     r   
_lazy_callr@   O   s    
 ::j%((--h	8N8N8PQZZ&&))(I4J4J4LM   (I,B,B,D!EFr   c                      [        5         g)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_initr   r   r   initrC   ]   s	     Lr   c            	         [        5       (       d  [        [        S5      (       a  g [           [        5       (       a
   S S S 5        g [	        5       (       a  [        S5      e[        5       (       d  [        S5      e[        R                  R                  5         S[        l        [        R                  S [        R                  5        5       5         [         H  u  p U " 5         M     ['        [        S5        SqS S S 5        g ! [          a1  nS[#        U5       SSR%                  U5       3n[!        U5      UeS nAff = f! ['        [        S5        f = f! , (       d  f       g = f)	Nis_initializingzuCannot re-initialize XPU in forked subprocess. To use XPU with multiprocessing, you must use the 'spawn' start methodz#Torch not compiled with XPU enabledTc              3   6   #    U  H  o(       d  M  Uv   M     g 7fNr   ).0callss     r   	<genexpr>_lazy_init.<locals>.<genexpr>}   s     X0NuRWUU0Ns   
	z5XPU call failed lazily at initialization with error: z'

XPU call was originally invoked at:

 )r3   hasattr_tls_initialization_lockr2   RuntimeErrorr   AssertionErrorr   r   	_xpu_initrE   r   extendr8   	get_calls	Exceptionstrjoindelattrr1   )queued_callorig_tracebackemsgs       r   rB   rB   f   s=   74):;;	 	 
	 I  ~~ !FGG  $X0B0L0L0NXX	-/<+0M 0= D+,C 
	2 ! 0OPSTUPVx XBBD''.BYAZ\  $C.a/0 D+,A 
	sN   EBEED%E)E
D?,D::D??EEE
E%c                   >    \ rS rSrS\4S jrS rS\S\S\4S jrS	r	g
)_DeviceGuard   indexc                     Xl         SU l        g Nidxprev_idx)selfr`   s     r   __init___DeviceGuard.__init__   s    r   c                 `    [         R                  R                  U R                  5      U l        g rG   r   xpur$   re   rf   rg   s    r   	__enter___DeviceGuard.__enter__       		22488<r   typevaluer:   c                 `    [         R                  R                  U R                  5      U l        gr   r   rl   r'   rf   re   rg   rq   rr   r:   s       r   __exit___DeviceGuard.__exit__       9933DMMBr   rd   N)
__name__
__module____qualname____firstlineno__intrh   rn   r   rv   __static_attributes__r   r   r   r^   r^      s-    c =S   r   r^   c                   B    \ rS rSrSrS \4S jrS rS\S\S\4S jrS	r	g
)r	      zContext-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``.
c                 0    [        USS9U l        SU l        g )NToptionalrc   )r   re   rf   )rg   r	   s     r   rh   device.__init__   s    $Vd;r   c                 `    [         R                  R                  U R                  5      U l        g rG   rk   rm   s    r   rn   device.__enter__   rp   r   rq   rr   r:   c                 `    [         R                  R                  U R                  5      U l        gr   rt   ru   s       r   rv   device.__exit__   rx   r   rd   N)
ry   rz   r{   r|   __doc__r   rh   rn   rv   r~   r   r   r   r	   r	      s2    s =S   r   c                   ,   ^  \ rS rSrSrU 4S jrSrU =r$ )	device_of   a	  Context-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.
c                 j   > UR                   (       a  UR                  5       OSn[        TU ]  U5        g rb   )is_xpu
get_devicesuperrh   )rg   objre   	__class__s      r   rh   device_of.__init__   s$    "%**cnn"r   r   )ry   rz   r{   r|   r   rh   r~   __classcell__)r   s   @r   r   r      s     r   r   c                 z    [        5         [        U 5      n U S:  a   [        R                  R	                  U 5        gg)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.
r   N)rB   r   r   r   _xpu_setDevicer   s    r   
set_devicer      s1     Lv&F{' r   c                 ,    [        U 5      R                  $ )am  Get 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namer   s    r   get_device_namer      s     !(---r   c                     [        U 5      n[        U5       Vs0 s H'  nUR                  S5      (       a  M  U[        X5      _M)     sn$ s  snf )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
)__
_pybind11_)r   dir
startswithgetattr)r	   propsprops      r   get_device_capabilityr      sR     "&)E JD34 	#ge""  s
   A
A
c                 @    [        5         [        U SS9n [        U 5      $ )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   )rB   r   _get_device_propertiesr   s    r   r   r      s      Lv5F!&))r   c                  R    [        5         [        R                  R                  5       $ )z0Return the index of a currently selected device.)rB   r   r   _xpu_getDevicer   r   r   current_devicer     s    L88""$$r   c                     [        U [        5      (       a  [        R                  " U 5      n U $ [        U [        5      (       a  [        R                  " SU 5      n U $ )zReturn the torch.device type object from the passed in device.

Args:
    device (torch.device or int or str): selected device.
rl   )
isinstancerV   r   r	   r}   r   s    r   _get_devicer   
  sJ     &#f% M 
FC	 	 eV,Mr   c                   Z    \ rS rSr% Sr\S   \S'   S\S   4S jrS rS\	S	\	S
\	4S jr
Srg)StreamContexti  a   Context-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streamc                 \    Xl         [        S S5      U l        U R                  c  SU l        g g )NTrc   )r   r   re   )rg   r   s     r   rh   StreamContext.__init__$  s+    $T4088DH r   c                    U R                   nUb  U R                  S:X  a  g [        R                  R	                  S 5      U l        U R
                  R                  UR                  :w  aL  [        UR                  5         [        R                  R	                  UR                  5      U l        S S S 5        [        R                  R                  U5        g ! , (       d  f       N.= frb   )	r   re   r   rl   current_streamsrc_prev_streamr	   dst_prev_stream
set_stream)rg   r   s     r   rn   StreamContext.__enter__*  s    [[
R$yy77= &&**;*;;
))*',yy'?'?
@Q@Q'R$ +		Z( +*s   >/C
C#rq   rr   r:   c                 0   U R                   nUb  U R                  S:X  a  g U R                  R                  UR                  :w  a)  [        R
                  R                  U R                  5        [        R
                  R                  U R                  5        g rb   )r   re   r   r	   r   rl   r   r   )rg   rq   rr   r:   r   s        r   rv   StreamContext.__exit__6  sj    [[
R &&**;*;;II  !5!56		T112r   )r   re   r   r   N)ry   rz   r{   r|   r   r   __annotations__rh   rn   r   rv   r~   r   r   r   r   r     sF    	 +,,x(:; 
)3S 3 3 3r   r   r   r   c                     [        U 5      $ )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``.
)r   r   s    r   r   r   A  s       r   c                 B    [         R                  R                  U UUS9  g)zset 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)r   r   _xpu_setStreamr   s      r   _set_stream_by_idr   J  s$     
HH!  r   c                 r    U c  g[        5         [        U R                  U R                  U R                  S9  g)a  Set 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   )rB   r   r   r   r   r   s    r   r   r   X  s4     ~L""((&&r   c                     [        5         [        R                  R                  [	        U SS95      n[        US   US   US   S9$ )a:  Return 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   r   r      r   )rB   r   r   _xpu_getCurrentStreamr   r   )r	   
streamdatas     r   r   r   k  sJ     L//&40J Q-jmTU r   data_ptrc                     [        5         [        R                  R                  U [	        USS95      n[        US   US   US   S9$ )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   r   r   r   r   )rB   r   r   _xpu_getStreamFromExternalr   r   )r   r	   r   s      r   get_stream_from_externalr   }  sM    $ L44#FT:J Q-jmTU r   c                 h    [        5         [        U SS9n [        R                  R	                  U 5      $ )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   )rB   r   r   r   _xpu_synchronizer   s    r   synchronizer     s*     Lv5F88$$V,,r   c                      [        5       (       d  / $ [        R                  R                  5       n U c  / $ U R	                  5       $ )z<Return list XPU architectures this library was compiled for.)r   r   r   _xpu_getArchFlagssplit)
arch_flagss    r   get_arch_listr     s:    >>	++-J	r   c                  l    [        5       n [        U 5      S:X  a  gSSR                  S U  5       5       3$ )zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.r   rL   z-device ,c              3   $   #    U  H  ov   M     g 7frG   r   )rH   archs     r   rJ   $get_gencode_flags.<locals>.<genexpr>  s     :	t	s   )r   lenrW   )	arch_lists    r   get_gencode_flagsr     s5    I
9~chh:	::;<<r   c                 n    U R                   nUc
  [        5       n[        R                  R                  U   $ )ziReturn the XPU Generator object for the given device.

Args:
    device (torch.device): selected device.
)r`   r   r   rl   r   )r	   re   s     r   _get_generatorr     s/     ,,C
{99'',,r   offsetc                 B   ^ ^ [        U5      mUU 4S jn[        U5        g)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).
c                  >   > [        T5      n U R                  T5        g rG   )r   
set_offset)default_generatorfinal_devicer   s    r   cb!_set_rng_state_offset.<locals>.cb  s    *<8$$V,r   N)r   r@   )r   r	   r   r   s   `  @r   _set_rng_state_offsetr     s     v&L- rNr   c                 b    [        5         [        U 5      n[        U5      nUR                  5       $ )a4  Return 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.
)rB   r   r   
get_offset)r	   r   r   s      r   _get_rng_state_offsetr     s-     Lv&L&|4''))r   )
empty_cachemax_memory_allocatedmax_memory_reservedmem_get_infomemory_allocatedmemory_reservedmemory_statsmemory_stats_as_nested_dictreset_accumulated_memory_statsreset_peak_memory_stats)	get_rng_stateget_rng_state_allinitial_seedmanual_seedmanual_seed_allr6   r5   set_rng_stateset_rng_state_all)+r   r   r   r   r   r   r	   r   r+   r   r   r   r   r   r   r   r   r   rC   r   r-   r/   r3   r   r   r   r   r   r   r   r   r   r   r   r6   r5   r   r   r   r   r   streamsr   rG   )rl   )ar   	threadingr:   	functoolsr   typingr   r   r   r   r   torch._Cr	   _devicetorch._utilsr
   r   _utilsr   r   r   r   r1   localrN   LockrO   r   listtuplerV   r   r   r   r2   r}   	_device_tr8   r   	Generatorboolr   r   _xpu_exchangeDevicer$   _xpu_maybeExchangeDevicer'   r+   r-   r/   r3   r@   rC   rB   r^   r   r   r   dictr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   memoryr   r   r   r   r   r   r   r   r   r   randomr   r   r   r   r   r6   r5   r   r   __all__r   r   r   <module>r     s      1 1   # 6 % "  ~~'   t	(2t8
d3i
'(  %(($6F'3T)*	%' 02 E%((,,- 2d 
 >> 8888xx33"XX>> ''=>N N NNs Ns N 1*c * *d 
2
G%P
 
 ( 
(y 
(T 
(.HY/ .3 . 4(9"5 c3h  4*(9"5 *AU *% %
c345 
%,, 
'3 '3T!8./ !M !v &8I. & & 26#I.6
-	 
-T 
-tCy =3 =	-5<< 	-EHH,>,> 	- :?sC56	&*%S%,,(>"? *C *"  
 
 
,r   