SjT"UdZddlmZddlZddlZddlmZddlmZm Z m Z ddl Z ddl Z ddl mZmZe r ddlmZddlmZd d lmZd d lmZmZmZmZmZd d lmZmZd aej@Z!ejDZ#ga$de%d<e&e jNddZ(ea)dZ*de%d<d@dZ+e+rCe jNjXZ,e jNjZZ.e jNj^Z0nedZ,dAdZ.dAdZ0ed dBdZ1d@dZ2dCdDdZ3d@dZ4dZ5dEd Z6dEd!Z7dEd"Z8Gd#d$Z9Gd%dZ:Gd&d'e:Z;dFd(Z dG dJd+Z?dBd,Z@dKd-ZAdLd.ZBGd/d0ZCdMd1ZDdEd2ZEdNd3ZFdGdOd4ZGdGdPd5ZHdGdFd6ZIdQd7ZJdRd8ZKdSd9ZL dT dUd:ZMdTdVd;ZNd dekelelfZmgd?Zny)Wz 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_isInBadForkcyNFrQ/var/www/html/ia-enhanced/venv/lib/python3.12/site-packages/torch/xpu/__init__.pyr,srrztuple[torch._C.Generator]default_generatorsc6tjjS)z(Return true if compile with XPU support.)torch_C_has_xpurrr _is_compiledr"1s 88  r_XpuDevicePropertiesdevicectdNz(PyTorch was compiled without XPU supportNotImplementedErrorr$s r_exchange_devicer*>!"LMMrctdr&r'r)s r_maybe_exchange_devicer-Ar+r)maxsizecTtsytjjS)z*Return the number of XPU device available.r)r"rr _xpu_getDeviceCountrrr device_countr1Es > 88 ' ' ))rctdkDS)z7Return a bool indicating if XPU is currently available.r)r1rrr is_availabler3Ms >A rcptsy|xs(tjjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r3rxpuget_device_propertieshas_bfloat16_conversions)including_emulations ris_bf16_supportedr9Ss. > F 99 * * , E ErchtsytjjjS)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)r3rr5r6'has_subgroup_matrix_multiply_accumulaterrris_tf32_supportedr<]s% > 99 * * , T TTrc(txr t S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrris_initializedr@hs  1 111rc ftr|y|jddr)tj|t j y|jddr)tj |t j ytj|t j fy)Nseed_allFseed) r@get_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrappend)callablekwargss r _lazy_callrMms{  ::j% (  - -h 8N8N8P Q ZZ &  ) )(I4J4J4L M  (I,B,B,D!E Frcty)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_initrrrinitrP{s Lrc tsttdryt5tr dddyt r t dt s tdtjjdt_ tjdtjD tD] \}} | t'tddadddy#t $r1}dt#|ddj%|}t!||d}~wwxYw#t'tdwxYw#1swYyxYw) 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 enabledTc3&K|] }|s| ywNr).0callss r z_lazy_init..sXuRWUXsz5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )r@hasattr_tls_initialization_lockr? RuntimeErrorr"AssertionErrorrr _xpu_initrRrextendrE get_calls Exceptionstrjoindelattrr>) queued_callorig_tracebackemsgs rrOrOsA74):; !    !!  I ~ !FG G  $X0B0L0L0NXX -/< 0+ ^0M 0 D+ , C!!2!0OPSTUPVxXBBD''.BYAZ\$C.a/ 0 D+ ,A!!sM D=BD=9 D(C+ D(D=+ D%4,D  D%%D((D::D==Ec"eZdZddZdZddZy) _DeviceGuardc ||_d|_yN)idxprev_idx)selfindexs r__init__z_DeviceGuard.__init__s rc`tjj|j|_yrTrr5r*rnrorps r __enter__z_DeviceGuard.__enter__ 22488< rc`tjj|j|_yrrr5r-rornrptypevaluerGs r__exit__z_DeviceGuard.__exit__9933DMMBrN)rqintreturnNoner{rr|rrGr)__name__ __module__ __qualname__rrrvr}rrrrjrjs=rrjc&eZdZdZddZdZddZy)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``. c6t|d|_d|_y)NToptionalrm)r rnro)rpr$s rrrzdevice.__init__s$Vd; rc`tjj|j|_yrTrtrus rrvzdevice.__enter__rwrc`tjj|j|_yrryrzs rr}zdevice.__exit__r~rN)r$rrrr)rrr__doc__rrrvr}rrrr$r$s=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. c`|jr|jnd}t| |yrl)is_xpu get_devicesuperrr)rpobjrn __class__s rrrzdevice_of.__init__s$"%**cnn" rrr)rrrrrr __classcell__)rs@rrrsrrcxtt|}|dk\r tjj |yy)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)rOr rr _xpu_setDevicer)s r set_devicers1L 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 )r6namer)s rget_device_namers ! ( - --rc t|}ttttt dt ttf}t|Dcic].}|jdstt||x}|r||0c}Scc}w)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 N__) r6rfloatboolrbr{listtupledictdir startswith isinstancegetattr)r$propsserializable_typeskeyr|s rget_device_capabilityrsv "& )EudCdT5$Ou:  ~~d# !447I J U   s3A>cFtt|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)rOr _get_device_propertiesr)s rr6r6s!NL v 5F !& ))rcRttjjS)z0Return the index of a currently selected device.)rOrr _xpu_getDevicerrrcurrent_devicer=sL 88 " " $$rct|trtj|}|St|trtjd|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r5)rrbrr$rr)s r _get_devicerCsD &#f% M FC eV, Mrctt|d}t|d}tjj ||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)rOr rr _xpu_canDeviceAccessPeer)r$peers rcan_device_access_peerrPs8L v 5F TD 1D 88 , ,VT ::rc2eZdZUdZded<ddZdZd dZy) 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_streamc\||_tdd|_|jd|_yy)NTrm)streamr rn)rprs rrrzStreamContext.__init__ns- $T40 88 DH rc|j}||jdk(rytjj d|_|j j |j k7rLt |j 5tjj |j |_dddtjj|y#1swY)xYwrl) rrnrr5current_streamsrc_prev_streamr$dst_prev_stream set_stream)rprs rrvzStreamContext.__enter__ts[[  R $yy77=    & &**;*; ; ))* S',yy'?'? @Q@Q'R$ S Z( S Ss ;/CCc*|j}||jdk(ry|jj|jk7r)tj j |jtj j |jyrl)rrnrr$rr5rr)rpr{r|rGrs rr}zStreamContext.__exit__sj[[  R     & &**;*; ; II !5!5 6 T112rN)rrrrr)rrrr__annotations__rrrvr}rrrrr`s (' )3rrct|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   rcHtjj|||y)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_idrs$ HH!rcv|ytt|j|j|jy)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)rOrrrrrs rrrs4~L""((&&rcttjjt |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)rOrr _xpu_getCurrentStreamr r)r$ streamdatas rrrsJL//&40J Q-jmTU rcttjj|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)rOrr _xpu_getStreamFromExternalr r)data_ptrr$rs rget_stream_from_externalrsM L44#FT:J Q-jmTU rcntt|d}tjj |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)rOr rr _xpu_synchronizer)s r synchronizers*L v 5F 88 $ $V ,,rc~tsgStjj}|gS|j S)z ++-J    rcjt}t|dk(ryddjd|DS)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rrXz-device ,c3 K|]}|ywrTr)rUarchs rrWz$get_gencode_flags..s:t:s )rlenrc) arch_lists rget_gencode_flagsrs5I 9~ chh: ::; <t}|jyrT)r set_offset)default_generator final_deviceoffsets rcbz!_set_rng_state_offset..cbs*<8$$V,rNr)rrM)rr$rrs` @r_set_rng_state_offsetr sv&L-rNrcbtt|}t|}|jS)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. )rOrr get_offset)r$rrs r_get_rng_state_offsetrs-Lv&L&|4  ' ' ))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_allrCrB set_rng_stateset_rng_state_all _POOL_HANDLE)9rrrrrrrrrrr$rr1rrrrr6rrrrrrrrPrr3r9rr@r<rrrrrrrrrrrrrrrrCrBrrrr rrstreamsr)rr)r$rrr)rr)T)r8rrrr)r$r rrrT)r$r rrb)r$r rzdict[str, Any])r$r rr#)r$int | str | torch.devicer torch.device)r$r rr rr)rrrr)rrrr)r$r rr)rrr$r rr)rz list[str])rrb)r$r rztorch._C.Generator)r5)rrr$r rr)r$r rr)or __future__r threadingrG functoolsrtypingrrrrtorch._C torch._utilsrr collections.abcr torch.typesr _utilsr graphsrrrrrr rrr>localrZLockr[rrrr r?rErr"r#_xpu_exchangeDevicer*_xpu_maybeExchangeDevicer-r1r3r9r<r@rMrPrOrjr$rrrrr6rrrrrrrrrrrrrrrmemoryrrrrrrrrrrrrrrrrrrandomrrrrrrCrBrr rrr __all__rrrrsK#.. 6("%# y%y~~'%(($6 F%'02-2 > 8888xx33"XX>>''=>NN 1** U2 G%P  (   ( . 42)* )*)*X%  ; (3(3V! &$2 -= -5: 1 & *"&   ~uS#X7 : r