
    Χg3+                        U d Z ddlZddlZddlmZmZmZmZmZm	Z	m
Z
 ddlZddlmZmZ ddlmZmZmZ ddlmZ ddlmZ e
eeedf         Zej        Zej        Zd	ag aee	eg df         ee         f                  ed
<    ej                    Z  ej!                    Z" e            Z#d Z$d Z%de&fdZ'd(dZ( G d de)          Z*de&fdZ+de&fdZ,d)dee         ddfdZ-defdZ.defdZ/d)dee         defdZ0d)dee         defdZ1d)dee         deeef         fdZ2defdZ3deddfdZ4 G d d          Z G d d           Z5ded!         de5fd"Z6d*de
eeej        f         defd$Z7	 d*d%ede
eeej        f         ddfd&Z8g d'Z9dS )+zH
This package enables an interface for accessing MTIA backend in python
    N)AnyCallableDictListOptionalTupleUnion)deviceTensor)_dummy_type_LazySeedTrackerclassproperty)Device   )_get_device_indexF_queued_callsc                  "    t                       d S N)
_lazy_init     O/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/mtia/__init__.pyinitr   !   s    LLLLLr   c                  .    t           ot                       S )z9Return whether PyTorch's MTIA state has been initialized.)_initialized_is_in_bad_forkr   r   r   is_initializedr   %   s    1 1 111r   returnc                  >    t           j                                        S r   )torch_C_mtia_isInBadForkr   r   r   r   r   *   s    8%%'''r   c            	      ,   t                      st          t          d          rd S t          5  t                      r	 d d d            d S t	                      rt          d          t                      st          d          t          j	        
                                 dt          _        t                                          D ]} | rt                              |            	 t          D ]Z\  }}	  |             # t           $ r=}dt#          |           dd                    |           }t'          |          |d }~ww xY w	 t)          t          d           n# t)          t          d           w xY wdad d d            d S # 1 swxY w Y   d S )Nis_initializingzwCannot re-initialize MTIA in forked subprocess. To use MTIA with multiprocessing, you must use the 'spawn' start methodzTorch not compiled with MTIA enabled. Ensure you have `import mtia.host_runtime.torch_mtia` in your python src file and include `//mtia/host_runtime/torch_mtia:torch_mtia` as your target dependency!Tz6MTIA call failed lazily at initialization with error: z(

MTIA call was originally invoked at:

 )r   hasattr_tls_initialization_lockr   RuntimeError_is_compiledAssertionErrorr    r!   
_mtia_initr$   _lazy_seed_tracker	get_callsr   append	ExceptionstrjoinDeferredMtiaCallErrordelattrr   )callsqueued_callorig_tracebackemsgs        r   r   r   .   sC    74):;; 	 . .  	. . . . . . . .  	I   ~~ 	 *   	  $'1133 	, 	,E ,$$U+++	-/< < <+^<KMMMM  < < <]QTUVQWQW ] ]CE77>CZCZ] ]  044!;<< D+,,,,GD+,,,,]. . . . . . . . . . . . . . . . . .sT   F	
BF	'E 4
C?>E ?
E	8EEE 
F	 E77F		FFc                       e Zd ZdS )r3   N)__name__
__module____qualname__r   r   r   r3   r3   c   s        Dr   r3   c                  >    t           j                                        S )z*Return true if compiled with MTIA support.)r    r!   _mtia_isBuiltr   r   r   r*   r*   g   s    8!!###r   c                  F    t                      sdS t                      dk    S )z'Return true if MTIA device is availableFr   )r*   device_countr   r   r   is_availablerB   l   s"    >> u>>Ar   r
   c                     t           j                            |           5  t           j                                        cddd           S # 1 swxY w Y   dS )z?Waits for all jobs in all streams on a MTIA device to complete.N)r    mtiar
   r!   _mtia_deviceSynchronizer
   s    r   synchronizerG   t   s    			6	"	" 2 2x//112 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2s   AAAc                  >    t           j                                        S )z,Return the number of MTIA devices available.)r    r!   _accelerator_hooks_device_countr   r   r   rA   rA   z   s    833555r   c                  >    t           j                                        S )z0Return the index of a currently selected device.)r    r!   %_accelerator_hooks_get_current_devicer   r   r   current_devicerL      s    899;;;r   c                 ^    t           j                            t          | d                    S )aS  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.mtia.current_device`, if :attr:`device` is ``None``
            (default).
    Toptional)r    r!   _mtia_getCurrentStreamr   rF   s    r   current_streamrQ      (     8**+<Vd+S+S+STTTr   c                 ^    t           j                            t          | d                    S )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.mtia.current_device`, if :attr:`device` is ``None``
            (default).
    TrN   )r    r!   _mtia_getDefaultStreamr   rF   s    r   default_streamrU      rR   r   c                 ~    t                      si S t          j                            t	          | d                    S )a  Return a dictionary of MTIA memory allocator statistics for a given device.

    Args:
        device (torch.device or int, optional) selected device. Returns
            statistics for the current device, given by current_device(),
            if device is None (default).
    TrN   )r   r    r!   _mtia_memoryStatsr   rF   s    r   memory_statsrX      s;      	8%%&7&N&N&NOOOr   streamc                 L    | dS t           j                            |            dS )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``.
    N)r    r!   _mtia_setCurrentStreamrY   s    r   
set_streamr]      s*     ~	H##F+++++r   c                 r    t          |           } | dk    r!t          j                            |            dS dS )zSet the current device.

    Args:
        device (torch.device or int): selected device. This function is a no-op
            if this argument is negative.
    r   N)r   r    r!   %_accelerator_hooks_set_current_devicerF   s    r   
set_devicer`      s=     v&&F{{66v>>>>> {r   c                   8    e Zd ZdZd efdZd ZdededefdZd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``.
    c                 @    t          |d          | _        d| _        d S )NTrN   )r   idxprev_idx)selfr
   s     r   __init__zdevice.__init__   s!    $Vd;;;r   c                 X    t           j                            | j                  | _        d S r   )r    r!   (_accelerator_hooks_maybe_exchange_devicerd   re   )rf   s    r   	__enter__zdevice.__enter__   s    II$(SSr   typevalue	tracebackc                 X    t           j                            | j                  | _        dS )NF)r    r!   ri   re   rd   )rf   rk   rl   rm   s       r   __exit__zdevice.__exit__   s     8DDT]SSur   N)r;   r<   r=   __doc__r   rg   rj   ro   r   r   r   r
   r
      st         s    T T TS        r   c                   \    e Zd ZU dZed         ed<   ded         fdZd Zdeded	efd
Z	dS )StreamContexta  Context-manager that selects a given stream.

    All MTIA 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.mtia.Stream
cur_streamrY   c                    d | _         || _        t          d d          | _        t          j                                        s| j        d| _        t          j                                        sd nt          j                            d           | _	        t          j                                        sd nt          j                            d           | _
        d S )NTrc   )rt   rY   r   rd   r    jitis_scriptingrD   rU   src_prev_streamdst_prev_stream)rf   rY   s     r   rg   zStreamContext.__init__   s    $T400y%%'' 	x 	..00UDDej6O6OPT6U6U 	 	..00UDDej6O6OPT6U6U 	r   c                    | j         }|| j        dk    rd S t          j                            d           | _        | j        j        |j        k    rUt          |j                  5  t          j                            |j                  | _        d d d            n# 1 swxY w Y   t          j                            |           d S Nrc   )	rY   rd   r    rD   rQ   rx   r
   ry   r]   )rf   rt   s     r   rj   zStreamContext.__enter__   s    [
RF$z88>> &**;;;
)** T T',z'@'@AR'S'S$T T T T T T T T T T T T T T T
j)))))s   $*BB!Brk   rl   rm   c                     | j         }|| j        dk    rd S | j        j        |j        k    r$t          j                            | j                   t          j                            | j                   d S r{   )rY   rd   rx   r
   r    rD   r]   ry   )rf   rk   rl   rm   rt   s        r   ro   zStreamContext.__exit__  sl    [
RF &**;;;J!!$"6777
d233333r   N)
r;   r<   r=   rp   r   __annotations__rg   rj   r   ro   r   r   r   rr   rr      s         	 	 ,----
x(;< 
 
 
 
* * *4S 4 4 4 4 4 4 4 4r   rr   rs   c                      t          |           S )a+  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``.
    ..Note:: In eager mode stream is of type Stream class while in JIT it doesn't support torch.mtia.stream
    )rr   r\   s    r   rY   rY     s        r   rD   c                 ~    t          j        dt          d           t          j        dgt          j        |           S )zReturns the random number generator state as a ByteTensor.

    Args:
        device (torch.device or int, optional): The device to return the RNG state of.
            Default: ``'mtia'`` (i.e., ``torch.device('mtia')``, the current mtia device).
    z.get_rng_state is not implemented in torch.mtia   
stacklevelr   )dtyper
   )warningswarnUserWarningr    zerosuint8rF   s    r   get_rng_stater     sC     M8   
 ;s%+f====r   	new_statec                 >    t          j        dt          d           dS )a  Sets the random number generator state.

    Args:
        new_state (torch.ByteTensor): The desired state
        device (torch.device or int, optional): The device to set the RNG state.
            Default: ``'mtia'`` (i.e., ``torch.device('mtia')``, the current mtia device).
    z.set_rng_state is not implemented in torch.mtiar   r   N)r   r   r   )r   r
   s     r   set_rng_stater   +  s0     M8     r   )r   rB   r   rG   rA   rL   rQ   rU   rX   r`   r]   rY   r
   r   r   )r   Nr   )rD   ):rp   	threadingr   typingr   r   r   r   r   r   r	   r    r
   _devicer   torch._utilsr   r   r   torch.typesr   _utilsr   r1   int	_device_tEventStreamr   r   r}   localr'   Lockr(   r-   r   r   boolr   r   r0   r3   r*   rB   rG   rA   rL   rQ   rU   rX   r]   r`   rr   rY   r   r   __all__r   r   r   <module>r      sO          D D D D D D D D D D D D D D D D D D  + + + + + + + + E E E E E E E E E E       % % % % % % '3T)*	 		  t	(2t8
d3i
'(    y%y~'' %%''   2 2 2
( ( ( ( (2 2 2 2j	 	 	 	 	I 	 	 	$d $ $ $ $
d    2 2+ 2t 2 2 2 26c 6 6 6 6
< < < < <
	U 	U8I. 	U& 	U 	U 	U 	U	U 	U8I. 	U& 	U 	U 	U 	U
P 
P), 
PS#X 
P 
P 
P 
P,v , , , ,	?y 	?T 	? 	? 	? 	?       (74 74 74 74 74 74 74 74t!8/0 !] ! ! ! !> >%S%, 67 >V > > > >  @F $S#u|%;<	   "  r   