[iKUdZddlZddlZddlmZddlmZddlmZm Z m Z ddl Z ddl Z ddl m ZddlmZmZdd lmZdd lmZmZd aejZejZgaeeegdfeefe d <e!e j"d dZ#e eee$dfZ%ea&dZ'ee j"j(e d<de)fdZ*e*r%e j"j+Z+e j"j,Z-e j"j.Z/nedZ+de$de$fdZ-de$de$fdZ/edde$fdZ0de)fdZ1dDde)de)fdZ2de)fdZ3dZ4dEdZ5dEd Z6dEd!Z7Gd"d#Z8Gd$dZ Gd%d&e Z9de%ddfd'Z:dFde%dzdefd(Z;eddFde%dzdede$fd+Z?de$eze j zde j fd,Z@de%d-e%de)fd.ZAGd/d0ZBd1e d2deBfd3ZCdEd4ZDd1eddfd5ZEdFde%dzdefd6ZFdFd7e$de%dzdefd8ZGdFde%ddfd9ZHdeefd:ZIdefd;ZJde j de j"j(fd<ZK dGd>e$de$eze j zddfd?ZLdGde$eze j zde$fd@ZMddAlNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\ddBl]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfgdCZgdS)Hz 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)Callable) lru_cache)AnyOptionalUniondevice) _dummy_type_LazySeedTracker)_get_device_index)EventStreamF _queued_calls_xpu_isInBadForkcdSNFrE/var/www/icac/venv/lib/python3.11/site-packages/torch/xpu/__init__.pyrsrrdefault_generatorsreturnc$tjjS)z(Return true if compile with XPU support.)torch_C_has_xpurrr _is_compiledr%s 8 r_XpuDevicePropertiesr c tdNz(PyTorch was compiled without XPU supportNotImplementedErrorrs r_exchange_devicer$2!"LMMMrc tdr!r"rs r_maybe_exchange_devicer'5r%r)maxsizec^tsdStjS)z*Return the number of XPU device available.r)rrr_xpu_getDeviceCountrrr device_countr+9s) >>q 8 ' ' ) ))rc&tdkS)z7Return a bool indicating if XPU is currently available.r)r+rrr is_availabler-As >>A rTincluding_emulationcltsdS|p"tjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r-rxpuget_device_propertieshas_bfloat16_conversions)r.s ris_bf16_supportedr3Gs5 >>u F 9 * * , , ErchtsdStjjS)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)r-rr0r1'has_subgroup_matrix_multiply_accumulaterrris_tf32_supportedr6Qs, >>u 9 * * , , TTrc.tot S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrris_initializedr:\s  1 1 111rc tr |dS|ddr.t|t jdS|ddr.t|t jdSt|t jfdS)Nseed_allFseed) r:get_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrappend)callablekwargss r _lazy_callrGas G  ::j% ( ( G  - -h 8N8P8P Q Q Q Q Q ZZ & & G  ) )(I4J4L4L M M M M M  (I,B,D,D!E F F F F Frc"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_initrrrinitrJos LLLLLrc 2tsttdrdSt5tr ddddSt rt dt stdtj dt_ t dtD tD]Z\}} |#t $r=}dt#|dd|}t!||d}~wwxYw t'tdn#t'tdwxYwdaddddS#1swxYwYdS) 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 enabledTc3K|]}||V dSNr).0callss r z_lazy_init..s(XXuRWXUXXXXXXrz5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )r:hasattr_tls_initialization_lockr9 RuntimeErrorrAssertionErrorrr _xpu_initrLrextendr? get_calls Exceptionstrjoindelattrr8) queued_callorig_tracebackemsgs rrIrIxs074):;; !!      !!!!!!!!    I ~~ H !FGG G  $XX0B0L0L0N0NXXXXXX -/< 0 0+ ^0KMMMM 000\PSTUPVPV\\BD''.BYBY\\$C..a/ 0 0 D+ , , , ,GD+ , , , , C!!!!!!!!!!!!!!!!!!sTF  BF * E#7 DE# E  8EE  E# F #E::F  FFc8eZdZdeddfdZdZdededefd ZdS) _DeviceGuardindexrNc"||_d|_dSN)idxprev_idx)selfres r__init__z_DeviceGuard.__init__s rcXtj|j|_dSrNrr0r$rirjrks r __enter__z_DeviceGuard.__enter__ 2248<< rtypevaluerAcXtj|j|_dSrrr0r'rjrirkrrrsrAs r__exit__z_DeviceGuard.__exit__ 933DMBBur)__name__ __module__ __qualname__intrlrprrwrrrrdrdsncd===Srrdc<eZdZdZdeddfdZdZdededefd ZdS) 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``. rNc@t|d|_d|_dS)NToptionalrh)r rirj)rkr s rrlzdevice.__init__s!$Vd;;; rcXtj|j|_dSrNrnros rrpzdevice.__enter__rqrrrrsrAcXtj|j|_dSrrurvs rrwzdevice.__exit__rxr)ryrzr{__doc__rrlrprwrrrr r sxst===Src$eZdZdZdfd ZxZS) 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. rNc|jr|nd}t|dSrg)is_xpu get_devicesuperrl)rkobjri __class__s rrlzdevice_of.__init__s<"%*4cnn" rrN)ryrzr{rrl __classcell__)rs@rrrsGrrctt|}|dkr!tj|dSdS)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)rIr rr_xpu_setDevicers r set_devicersFLLL v & &F {{ '''''{rc*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 )r1namers rget_device_namers ! ( ( --rct|ttttt dt ttffdtDS)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 Nci|]:}|dtt|x7|;S)__) startswith isinstancegetattr)rOkeypropsserializable_typesrss r z)get_device_capability..sa    ~~d##  !4!447I J J   U   r) r1r|floatboolr\rrlisttupledictdir)r rrrss @@@rget_device_capabilityrsl "& ) )EudCdT5$O      u::   rc^tt|d}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)rIr _get_device_propertiesrs rr1r1s-LLL v 5 5 5F !& ) ))rcZttjS)z0Return the index of a currently selected device.)rIrr_xpu_getDevicerrrcurrent_devicersLLL 8 " " $ $$rct|trtj|}n*t|trtjd|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r0)rr\rr r|rs r _get_devicersO &#-f%% FC -eV,, Mrpeerctt|d}t|d}tj||S)a/Query whether a device can access a peer device's memory. Args: device (torch.device or int or str): selected device. peer (torch.device or int or str): peer device to query access to. Returns: bool: ``True`` if ``device`` can access ``peer``, ``False`` otherwise. Tr)rIr rr_xpu_canDeviceAccessPeer)r rs rcan_device_access_peerr)sILLL v 5 5 5F TD 1 1 1D 8 , ,VT : ::rc`eZdZUdZeded<dedddfdZdZd ed ed efd 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_streamstreamrNc^||_tdd|_|j d|_dSdS)NTrh)rr ri)rkrs rrlzStreamContext.__init__Gs5 $T400 8 DHHH  rc|j}| |jdkrdStjd|_|jj|jkrUt |j5tj|j|_dddn #1swxYwYtj|dSrg) rrirr0current_streamsrc_prev_streamr dst_prev_stream set_stream)rkrs rrpzStreamContext.__enter__Ms[  R F$y77==   &**; ; ; )** S S',y'?'? @Q'R'R$ S S S S S S S S S S S S S S S Z(((((s$*BB!BrrrsrAc|j}| |jdkrdS|jj|jkr$tj|jtj|jdSrg)rrirr rr0rr)rkrrrsrArs rrwzStreamContext.__exit__Ysl[  R F   &**; ; ; I !5 6 6 6 T122222r) ryrzr{rr__annotations__rlrprrwrrrrr9s  +,,,,x(:; ) ) )3S33333333rrrrc t|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``. )rrs rrrds   rcJtj|||dS)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_setStreamrs r_set_stream_by_idrms6 H!rcl|dStt|j|j|jdS)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)rIrrrrrs rrr{sJ~LLL"(&rcttjt |d}t |d|d|dS)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). Trrr r)rIrr_xpu_getCurrentStreamr r)r streamdatas rrrsaLLL//&4000J Q-jmTU   rdata_ptrcttj|t |d}t |d|d|dS)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. Trrr rr)rIrr_xpu_getStreamFromExternalr r)rr rs rget_stream_from_externalrsd LLL44#FT:::J Q-jmTU   rc~tt|d}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)rIr rr_xpu_synchronizers r synchronizers5LLL v 5 5 5F 8 $ $V , ,,rctsgStj}|gS|S)z> ++--J     rct}t|dkrdSddd|DS)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rrRz-device ,c3K|]}|VdSrNr)rOarchs rrQz$get_gencode_flags..s"::t::::::r)rlenr]) arch_lists rget_gencode_flagsrsJI 9~~r .cbs+*<88$$V,,,,,rr)rrG)rr rrs` @r_set_rng_state_offsetrsGv&&L-------rNNNNNrctt|}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. )rIrr get_offset)r rrs r_get_rng_state_offsetrs:LLLv&&L&|44  ' ' ) ))r)change_current_allocator empty_cacheget_per_process_memory_fractionmax_memory_allocatedmax_memory_reserved mem_get_infomemory_allocatedmemory_reserved memory_statsmemory_stats_as_nested_dictreset_accumulated_memory_statsreset_peak_memory_statsset_per_process_memory_fractionXPUPluggableAllocator) get_rng_stateget_rng_state_all initial_seed manual_seedmanual_seed_allr=r< set_rng_stateset_rng_state_all)1rrrrrrrrrr rr+rrrrr1rrrrrrJrr-r3r:r6rrrrrrrrrrrr=r<rrrrrrstreamsr)TrrN)r0)hr threadingrAcollections.abcr functoolsrtypingrrrrtorch._Cr _device torch._utilsr r _utilsr rrrr8localrTLockrUrrrr\rrrr9r| _device_tr?r Generatorrrr_xpu_exchangeDevicer$_xpu_maybeExchangeDevicer'r+r-r3r6r:rGrJrIrdrrrrrr1rrrrrrrrrrrrrrrmemoryrrrrrrrrrrrrrrrandomrrrrrr=r<rr__all__rrrrs$$$$$$'''''''''' ######66666666%%%%%%"""""""" y%y~''t (2t8 d3i '('%($6 FF '3T) * %%''02E%(,-222d <>> N 88x3"X>';'=>>NNNNNNNsNsNNNN 1*c****d 44U4UUUU222 G G G G%%%%P        (         (y (T ( ( ( ( . .I, . . . . . 4)d"2d38n2 $**  *****"%%%%% c EL0 U\     ;9 ;I ;$ ; ; ; ; (3(3(3(3(3(3(3(3V!8./!M!!!!    v$&9t+v$sI4DPV2 - - -T - - - -tCy=3==== -5< -EH,> - - - -5: sU\1 & * *#)el": *s * * * *"                      2 2 2 r