GjTUdZddlmZddlZddlZddlmZddlmZm Z m Z ddl Z ddl Z ddl mZmZe r ddlmZddlmZd d lmZd d lmZmZmZmZmZd d lmZmZd aej Z!ej"Z#ga$de%d<e&e j'ddZ(ea)dZ*de%d<dTdZ+e+r%e j'j,Z,e j'j-Z.e j'j/Z0nedZ,dUdZ.dUdZ0ed dVdZ1dTdZ2dWdXd"Z3dTd#Z4d$Z5dYd&Z6dYd'Z7dYd(Z8Gd)d*Z9Gd+dZ:Gd,d-e:Z;dZd/Z d[d^d4Z?dVd5Z@d_d8ZAd`d:ZBGd;d<ZCdad?ZDdYd@ZEdbdBZFd[dcdCZGd[dddEZHd[dZdFZIdedHZJdfdIZKdgdKZL dhdidNZMdhdjdOZNd dPlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`d dQlambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZje dRekelelfZmgdSZndS)kz 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. ) annotationsN) lru_cache)AnyNewType TYPE_CHECKING) _dummy_type_LazySeedTracker)Callable)Device)_get_device_index)graphgraph_pool_handleis_current_stream_capturingmake_graphed_callablesXPUGraph)EventStreamFz*list[tuple[Callable[[], None], list[str]]] _queued_calls_xpu_isInBadForkcdSNFrU/var/www/html/Carbon-Document/venv/lib/python3.11/site-packages/torch/xpu/__init__.pyr,srrztuple[torch._C.Generator]default_generatorsreturnboolc$tjjS)z(Return true if compile with XPU support.)torch_C_has_xpurrr _is_compiledr$1s 8 r_XpuDevicePropertiesdeviceintc tdNz(PyTorch was compiled without XPU supportNotImplementedErrorr&s r_exchange_devicer->!"LMMMrc tdr)r*r,s r_maybe_exchange_devicer0Ar.r)maxsizec^tsdStjS)z*Return the number of XPU device available.r)r$r!r"_xpu_getDeviceCountrrr device_countr4Es) >>q 8 ' ' ) ))rc&tdkS)z7Return a bool indicating if XPU is currently available.r)r4rrr is_availabler6Ms >>A rTincluding_emulationcltsdS|p"tjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r6r!xpuget_device_propertieshas_bfloat16_conversions)r7s ris_bf16_supportedr<Ss5 >>u F 9 * * , , ErchtsdStjjS)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)r6r!r9r:'has_subgroup_matrix_multiply_accumulaterrris_tf32_supportedr?]s, >>u 9 * * , , TTrc.tot S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrris_initializedrChs  1 1 111rNonec tr |dS|ddr.t|t jdS|ddr.t|t jdSt|t jfdS)Nseed_allFseed) rCget_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrappend)callablekwargss r _lazy_callrQms 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_initrrrinitrT{s 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: )rChasattr_tls_initialization_lockrB RuntimeErrorr$AssertionErrorr!r" _xpu_initrVrextendrI get_calls ExceptionstrjoindelattrrA) queued_callorig_tracebackemsgs rrSrSs074):;; !!      !!!!!!!!    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  FFc$eZdZd dZdZdd Zd S) _DeviceGuardindexr'rrDc"||_d|_dSN)idxprev_idx)selfros r__init__z_DeviceGuard.__init__s rcXtj|j|_dSrXr!r9r-rsrtrus r __enter__z_DeviceGuard.__enter__ 2248<< rtypervaluerKcXtj|j|_dSrr!r9r0rtrsrur|r}rKs r__exit__z_DeviceGuard.__exit__ 933DMBBurN)ror'rrDr|rr}rrKr)__name__ __module__ __qualname__rvrzrrrrrnrnsK===rrnc(eZdZdZd dZdZd d Zd S)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``. rrrDc@t|d|_d|_dS)NToptionalrr)r rsrt)rur&s rrvzdevice.__init__s!$Vd;;; rcXtj|j|_dSrXrxrys rrzzdevice.__enter__r{rr|r}rKcXtj|j|_dSrrrs rrzdevice.__exit__rrN)r&rrrDr)rrr__doc__rvrzrrrrr&r&sU===rc$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. rrDc|jr|nd}t|dSrq)is_xpu get_devicesuperrv)ruobjrs __class__s rrvzdevice_of.__init__s<"%*4cnn" rrrD)rrrrrv __classcell__)rs@rrrsGrrr ctt|}|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)rSr r!r"_xpu_setDevicer,s r set_devicersFLLL v & &F {{ '''''{rrfc*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:namer,s rget_device_namers ! ( ( --rdict[str, Any]ct|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)rYkeypropsserializable_typesr}s r z)get_device_capability.. sa    ~~d##  !4!447I J J   U   r) r:r'floatrrfr|listtupledictdir)r&rrr}s @@@rget_device_capabilityrsl "& ) )EudCdT5$O      u::   rc^tt|d}t|S)aGet the properties of a device. Returns _XpuDeviceProperties containing the following device properties: - ``name`` (str): device name. - ``platform_name`` (str): SYCL platform name. - ``vendor`` (str): device vendor. - ``device_id`` (int): device identifier (product ID). - ``driver_version`` (str): driver version. - ``version`` (str): runtime version. - ``max_compute_units`` (int): number of parallel compute units. - ``gpu_eu_count`` (int): number of EUs (Execution Unit). - ``max_work_group_size``: (int): maximum number of work-items permitted in a work-group. - ``max_num_sub_groups`` (int): maximum number of sub-groups supported in a work-group. - ``memory_clock_rate`` (int) maximum clock rate of device's global memory in MHz. - ``memory_bus_width`` (int) maximum bus width between device and memory in bits. - ``sub_group_sizes``: (list[int]): a list of supported sub-group sizes. - ``local_mem_size`` (int): device local memory capacity that can be allocated per work-group in bytes. - ``has_fp16`` (bool): whether float16 dtype is supported. - ``has_fp64`` (bool): whether float64 dtype is supported. - ``has_atomic64`` (bool): whether 64-bit atomic operations are supported. - ``has_bfloat16_conversions`` (bool): whether bfloat16 conversions are supported. - ``has_subgroup_matrix_multiply_accumulate`` (bool): whether DPAS (Dot Product Accumulate Systolic) is supported. - ``has_subgroup_matrix_multiply_accumulate_tensor_float32`` (bool): whether DPAS with tf32 inputs is supported. - ``has_subgroup_2d_block_io`` (bool): whether 2D block I/O for efficient matrix multiplication is supported. - ``total_memory`` (int): device global memory in bytes. - ``gpu_subslice_count`` (int): number of subslice. - ``architecture`` (int): device architecture identifier (experimental). - ``type`` (str): device type, e.g. 'cpu', 'gpu', accelerator', 'host', 'unknown'. - ``uuid`` (Any): device UUID (Universal Unique ID), 16 bytes. 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)rSr _get_device_propertiesr,s rr:r:s.NLLL v 5 5 5F !& ) ))rcZttjS)z0Return the index of a currently selected device.)rSr!r"_xpu_getDevicerrrcurrent_devicer=sLLL 8 " " $ $$rint | str | torch.device torch.devicect|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. r9)rrfr!r&r'r,s r _get_devicerCsO &#-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)rSr r!r"_xpu_canDeviceAccessPeer)r&rs rcan_device_access_peerrPsILLL v 5 5 5F TD 1 1 1D 8 , ,VT : ::rc4eZdZUdZded<ddZdZdd ZdS) 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 | None cur_streamstreamrrDc^||_tdd|_|j d|_dSdS)NTrr)rr rs)rurs rrvzStreamContext.__init__ns5 $T400 8 DHHH  rc|j}| |jdkrdStjd|_|jj|jkrUt |j5tj|j|_dddn #1swxYwYtj|dSrq) rrsr!r9current_streamsrc_prev_streamr&dst_prev_stream set_stream)rurs rrzzStreamContext.__enter__ts[  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!Br|rr}rKc|j}| |jdkrdS|jj|jkr$tj|jtj|jdSrq)rrsrr&r!r9rr)rur|r}rKrs rrzStreamContext.__exit__sl[  R F   &**; ; ; I !5 6 6 6 T122222rN)rrrrDr)rrrr__annotations__rvrzrrrrrr`se  (''' ) ) )333333rrrrc 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 rrrs   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)r!r"_xpu_setStreamrs r_set_stream_by_idrs6 H!rrcl|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)rSrrrrrs rrrsJ~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)rSr!r"_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)rSr!r"_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)rSr r!r"_xpu_synchronizer,s r synchronizers5LLL v 5 5 5F 8 $ $V , ,,r list[str]ctsgStj}|gS|S)z> ++--J     rct}t|dkrdSddd|DS)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rr\z-device ,c3K|]}|VdSrXr)rYarchs rr[z$get_gencode_flags..s"::t::::::r)rlenrg) arch_lists rget_gencode_flagsrsJI 9~~r .cbs+*<88$$V,,,,,rNr)rrQ)rr&rrs` @r_set_rng_state_offsetr sGv&&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. )rSrr 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_reservedmemory_snapshot memory_statsmemory_stats_as_nested_dictMemPoolreset_accumulated_memory_statsreset_peak_memory_statsset_per_process_memory_fraction use_mem_poolXPUPluggableAllocator) get_rng_stateget_rng_state_all initial_seed manual_seedmanual_seed_allrGrF set_rng_stateset_rng_state_all _POOL_HANDLE)9rrrr rrrrrrr&rr4rrrrr:rrr r rrrrTr r6r<rrCr?rr rrrrrrrrrrrrrrGrFrrrrrrstreamsr)rr)r&r'rr')rr')T)r7rrrr)r&r rrDrX)r&r rrf)r&r rr)r&r rr%)r&rrr)r&r rr rr)rrrr)rrrrD)r&r rr)rr'r&r rr)rr)rrf)r&rrr)r9)rr'r&rrrD)r&rrr')or __future__r threadingrK functoolsrtypingrrrr!torch._C torch._utilsrr collections.abcr torch.typesr _utilsr graphsrrrrrrrrrAlocalr^Lockr_rrrr"rBrIrr$r%_xpu_exchangeDevicer-_xpu_maybeExchangeDevicer0r4r6r<r?rCrQrTrSrnr&rrrrr:rrrrrrrrrrrrrrrmemoryrrrrrrrrrrrrrrrrr randomr r r r rrGrFrrrr'r__all__rrrr$s#""""".......... 66666666#((((((""""""%%%%%%#""""""" y%y~'''%($6 FF%%''022222 <>> N 88x3"X>';'=>>NNNNNNNN 1**** UUUU222 G G G G%%%%P        (         ( ( ( ( . . . . . 42)*)*)*)*)*X%%%%     ; ; ; ; (3(3(3(3(3(3(3(3V!!!!    &$2 - - - - -==== - - - -5:& * * * * *"&                      w~uS#X77 : : : r