^j:UdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZddlmZddlmZmZmZddlZddlZddlmZmZer ddlmZdd lmZd d lmZd d l m!Z!m"Z"m#Z#m$Z$m%Z%d d l&m'Z'm(Z(da)ejTZ+ejXZ-ga.de/d<e0ejbddZ2ea3dZ4de/d<da5de/d<ejlGddZ7ga8de/d<dZ9dYdZ:e:rCejbjvZ;ejbjxZ=ejbj|Z?nedZ;dZd Z=dZd!Z?d[d\d"Z@d]d#ZAd]d$ZBd^d%ZCd^d&ZDdYd'ZEd_d`d(ZFdYd)ZGd*ZHdad+ZIdad,ZJdad-ZKGd.d/ZLGd0dZMGd1d2eMZNdbd3ZOdcddd4ZPeddcded5ZQ dc dfd6ZRd^d7ZSdgd8ZTdhd9ZUGd:d;ZVdid<ZWdad=ZXdjd>ZYdcdkd?ZZdcdld@Z[dcdbdAZ\dmdBZ]dndCZ^dodDZ_ dp dqdEZ`dpdrdFZadGZbdsdHZcdtdIZddcdudJZedcdvdKZfdcdudLZgdcdvdMZhdcdudNZidcdvdOZjdcdudPZkdcdvdQZldcdudRZmdcdvdSZndcdwdTZod dUlpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZd dVlmZmZmZmZmZmZmZmZmZedWeeefZgdXZy)xz 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)byrefc_doublec_uint32c_void_pcastpointer) 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_isInBadForkcyNFr]/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/xpu/__init__.pyr"0sr rztuple[torch._C.Generator]default_generators int | None_cached_device_countczeZdZUded<dZded<dZded<dZd ed <dZd ed <dZd ed <dZ d ed <dZ d ed<y)_ZesDeviceInfor device_handleNr$ subdevice_idFbool is_integratedzc_void_p | Nonetemperature_handlefrequency_handle power_handle engine_handle memory_handle) __name__ __module__ __qualname____annotations__r)r+r,r-r.r/r0rr r!r'r'6sP#L*#M4*..(,o,$(L/(%)M?)%)M?)r r'zlist[_ZesDeviceInfo]_cached_zes_device_infosc6tjjS)z(Return true if compile with XPU support.)torch_C_has_xpurr r! _is_compiledr;Gs 88  r _XpuDevicePropertiesdevicectdNz(PyTorch was compiled without XPU supportNotImplementedErrorr=s r!_exchange_devicerCT!"LMMr ctdr?r@rBs r!_maybe_exchange_devicerFWrDr cBtjd}|ttdSg}|j dD]8} t |j }|dk\s#||vs(|j|:|S#t$r|rtd|ddgcYcSwxYw)a,Parse ``ZE_AFFINITY_MASK`` and return visible device ordinals. Returns a list of non-negative device ordinals specified by the mask. When the mask is unset, returns ``[0, 1, ..., 127]`` (the maximum range for ``int8_t`` device indices). Returns an empty list for unsupported COMPOSITE-style masks (e.g. ``"0.0,0.1"``). Args: strict (bool): If ``True``, raises ``ValueError`` on unsupported mask formats (e.g. COMPOSITE-style ``"0.0,0.1"``). If ``False`` (default), returns an empty list instead. ZE_AFFINITY_MASKN,z&Unsupported ZE_AFFINITY_MASK format: 'z='. Expected a comma-separated list of integers, e.g. '0,1,2'.r) osgetenvlistrangesplitintstrip ValueErrorappend)strictvarvisible_deviceselemxs r!_parse_visible_devicesrY[s ))& 'C {E#J!#O # & DJJL!A 6a.  " "1 % &   r|c}a | xs| S#t$rYywxYwcc}w)aEnumerate visible XPU devices via Level Zero Sysman and cache their info. Enumerates devices from the first Level Zero Sysman driver and counts those whose logical index appears in *visible_mask*. Only devices listed in the visible mask participate in counting. The populated ``_cached_zes_device_infos`` list is indexed by PyTorch device ordinal. Discrete GPUs (dGPUs) take priority: if any visible dGPU is found, only dGPUs are counted; integrated GPUs (iGPUs) are counted only when no visible dGPU exists. For tiled dGPUs (``numSubdevices > 0``), the counting depends on ``ZE_FLAT_DEVICE_HIERARCHY``: - **FLAT / COMBINED** (default): each sub-device is exposed as a separate top-level device and counted individually. - **COMPOSITE**: sub-devices are hidden; the whole physical device counts as one. Returns the visible device count, or a negative value on failure. rNcn|jk7rtj|d|jk7S)zQReturn True if the call failed (rc != ZE_RESULT_SUCCESS) after issuing a warning.) stacklevel)ZE_RESULT_SUCCESSwarningswarnrcmsgpyzess r!_zes_check_warnz/_enum_zes_device_infos.._zes_check_warns0 (( ( MM#! ,U,,,,r z"Can't initialize Level Zero Sysmanz(Can't get Level Zero Sysman driver countz*Can't get Level Zero Sysman driver handlesz(Can't get Level Zero Sysman device countz*Can't get Level Zero Sysman device handlesrZE_FLAT_DEVICE_HIERARCHY COMPOSITEz-Can't get Level Zero Sysman device properties)r(r)r+)rcrPrdstrreturnr*) re ExceptionzesInitr zesDriverGetrvaluezes_driver_handle_t zesDeviceGetzes_device_handle_trKrLr5clearsetzes_device_properties_t$ZES_STRUCTURE_TYPE_DEVICE_PROPERTIESstypezes_device_ext_properties_t(ZES_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIESrr rpNextzesDeviceGetPropertiesr*flags numSubdevicesrNrSr'r+) visible_maskrf driver_countdrivers device_countdevices#ZES_DEVICE_PROPERTY_FLAG_INTEGRATEDexpose_subdevicesvisible logical_indexnum_igpunum_dgpur=props ext_propsr+tiled num_slotsslotinfores @r!_enum_zes_device_infosrs. - u}}Q')MNA;L 5.52Q=u((<+=+==@G 5.84A;L 71:u\':DA2=u((<+=+==@G 71:u\':GD4+1' "<=L""$,GMHH --/@@ 557 HH 79-x8   ( (u > ; Y__/RRS "!Se&9&9A&=SBS+0E''a )$ D'(//"&,-2T&3!MHMH Q M ' FH5$ T=O=OD$    x{ t$ sJ?J-J- J*)J*ct|S)zRReturn the visible XPU device count via Level Zero Sysman, or negative on failure.)r)r}s r!_raw_device_count_zesrs !, //r c2t}|syt|S)z;Return the number of visible XPU devices, or -1 on failure.r[)rYr)rVs r!_device_count_zesrs,.O   11r c tsyttStsttdrt j j}n/t}|dkrt j jn|}tr|a|S)z Return the number of XPU device available. .. note:: This API will NOT poison fork if Level Zero Sysman discovery succeeds. See :ref:`multiprocessing-poison-fork-note` for more details. ris_initializing) r;r% _initializedhasattr_tlsr8r9_xpu_getDeviceCountr)count zes_counts r!rrsi >'##wt%67,,.%' 2;a-,,.Y$ Lr ctdkDS)z7Return a bool indicating if XPU is currently available.r)rrr r! is_availablers >A r cptsy|xs(tjjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)rr8xpuget_device_propertieshas_bfloat16_conversions)including_emulations r!is_bf16_supportedr%s. > F 99 * * , E Er chtsytjjjS)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)rr8rr'has_subgroup_matrix_multiply_accumulaterr r!is_tf32_supportedr/s% > 99 * * , T TTr c(txr t S)z8Return whether PyTorch's XPU state has been initialized.)r_is_in_bad_forkrr r!is_initializedr:s  1 111r c ftr|y|jddr)tj|t j y|jddr)tj |t j ytj|t j fy)Nseed_allFseed) rget_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrrS)callablekwargss r! _lazy_callr?s{  ::j% (  - -h 8N8N8P Q ZZ &  ) )(I4J4J4L M  (I,B,B,D!E Fr cty)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_initrr r!initrMs Lr c tsttdryt5tr dddyt r t dt s tdtjjdt_ tjdtjD tD] \}} | t'tddadddy#t $r1}dt#|ddj%|}t!||d}~wwxYw#t'tdwxYw#1swYyxYw) NrzuCannot 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..msXuRWUXsz5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )rrr_initialization_lockr RuntimeErrorr;AssertionErrorr8r9 _xpu_initrrextendr get_callsrkrijoindelattrr) queued_callorig_tracebackerds r!rrVsA74):; !    !!  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|_yNr[)idxprev_idx)selfindexs r!__init__z_DeviceGuard.__init__s r c`tjj|j|_yrr8rrCrrrs r! __enter__z_DeviceGuard.__enter__ 22488< r c`tjj|j|_yrr8rrFrrrtypernrs r!__exit__z_DeviceGuard.__exit__9933DMMBr N)rrPrjNonerr rnr rr )r1r2r3rrrrr r!rr~s=r rc&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)NToptionalr[)rrr)rr=s r!rzdevice.__init__s$Vd; r c`tjj|j|_yrrrs r!rzdevice.__enter__rr c`tjj|j|_yrrrs r!rzdevice.__exit__rr N)r=r rjrr)r1r2r3__doc__rrrrr r!r=r=s=r c$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| |yr)is_xpu get_devicesuperr)robjr __class__s r!rzdevice_of.__init__s$"%**cnn" r rjr)r1r2r3rr __classcell__)rs@r!rrsr rcxtt|}|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)rrr8r9_xpu_setDevicerBs r! set_devicers1L v &F { 'r c,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 )rnamerBs r!get_device_namers ! ( - --r c 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__) rrPfloatr*rirrMtupledictdir startswith isinstancegetattr)r=rserializable_typeskeyrns r!get_device_capabilityrsv "& )EudCdT5$Ou:  ~~d# !447I J U   s3A>cFtt|d}t|S)a Get 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. - ``last_level_cache_size`` (int): size in bytes of the device's last-level memory cache, shared across all Xe Cores (analogous to CUDA ``L2_cache_size``). - ``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. - ``is_integrated_gpu`` (bool): whether the device is an integrated GPU (iGPU). - ``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)rr_get_device_propertiesrBs r!rrs!RL v 5F !& ))r cRttjjS)z0Return the index of a currently selected device.)rr8r9_xpu_getDevicerr r!current_devicersL 88 " " $$r ct|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. r)rrir8r=rPrBs r! _get_devicer sD &#f% M FC eV, Mr ctt|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)rrr8r9_xpu_canDeviceAccessPeer)r=peers r!can_device_access_peerr $s8L v 5F TD 1D 88 , ,VT ::r c2eZdZUdZded<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)NTr[)streamrr)rrs r!rzStreamContext.__init__Bs- $T40 88 DH r c|j}||jdk(rytjj d|_|j j |j k7rLt |j 5tjj |j |_dddtjj|y#1swY)xYwr) rrr8rcurrent_streamsrc_prev_streamr=dst_prev_stream set_stream)rrs r!rzStreamContext.__enter__Hs[[  R $yy77=    & &**;*; ; ))* S',yy'?'? @Q@Q'R$ S Z( S Ss ;/CCc*|j}||jdk(ry|jj|jk7r)tj j |jtj j |jyr)rrrr=r8rrr)rrrnrrs r!rzStreamContext.__exit__Tsj[[  R     & &**;*; ; II !5!5 6 T112r N)rrrjrr)r1r2r3rr4rrrrr r!rr4s (' )3r rct|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 r!rr_s   r cHtjj|||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)r8r9_xpu_setStreamrs r!_set_stream_by_idr"hs$ HH!r cv|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)rr"rrr rs r!rrvs4~L""((&&r cttjjt |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). Trrrr)rr8r9_xpu_getCurrentStreamrr)r= streamdatas r!rrsJL//&40J Q-jmTU r cttjj|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. Trrrr%r)rr8r9_xpu_getStreamFromExternalrr)data_ptrr=r's r!get_stream_from_externalr+sM L44#FT:J Q-jmTU r cntt|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)rrr8r9_xpu_synchronizerBs r! synchronizer.s*L v 5F 88 $ $V ,,r c~tsgStjj}|gS|j S)z ++-J    r cjt}t|dk(ryddjd|DS)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rrz-device rJc3 K|]}|ywrr)rarchs r!rz$get_gencode_flags..s:t:s )r2lenr) arch_lists r!get_gencode_flagsr8s5I 9~ chh: ::; <t}|jyr)r: set_offset)default_generator final_deviceoffsets r!cbz!_set_rng_state_offset..cbs*<8$$V,r Nr)r r)r@r=rAr?s` @r!_set_rng_state_offsetrBsv&L-rNr cbtt|}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. )rr r: get_offset)r=r?r>s r!_get_rng_state_offsetrEs-Lv&L&|4  ' ' ))r cr ddl}|S#t$r tddt$r}td|d}~wwxYw)znReturn the imported pyzes module; raise ImportError if missing, RuntimeError if the GPU driver is unavailable.rNz7pyzes is required; install it with 'pip install pyzes'.zZFailed to import pyzes. Ensure the GPU driver is installed with Level Zero Sysman support.)re ImportErrorrkr)reerrs r! _import_pyzesrIsS  L  E    h  s6 16cLddl}||jk7rt|d|dy)zRRaise RuntimeError if the Level Zero Sysman call failed (rc != ZE_RESULT_SUCCESS).rNz (rc=))rer_rrbs r! _zes_checkrLs0 U $ $$cU%t1-..%r cts#ttddkr tdt t}||k\rtd|d|dy) zLEnsure the ZES device info cache is populated and validate the device index.T)rTrz2Failed to enumerate devices via Level Zero Sysman.z The device zD is out of range for Level Zero Sysman. It must be in the range [0, ).N)r5rrYrr6)r= total_devicess r!_zes_ensure_device_infosrPs_ # !"8"E F JST T01M &!efsettv w  r c :t}t|d}t|t|}|j |jS|j }|j }td}t|j|t|dd|jdk(r td|j|jz}t|j|t||dd}|D]}|j} |j| _t|j#|t| d| j$|j&k7rc|!| j(sr| j*|k(s|}n| j(r|}n| td ||_|S) aReturn the Level Zero Sysman GPU temperature sensor handle for the specified device. The result is cached in ``_ZesDeviceInfo.temperature_handle`` so that repeated calls skip sensor enumeration. ``_cached_zes_device_infos`` is lazily populated on the first call. Args: device (torch.device, str or int, optional): target device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). TrNrz5Can't get Level Zero Sysman temperature sensor count.z/No Level Zero Sysman temperature sensors found.z7Can't get Level Zero Sysman temperature sensor handles.z3Can't get Level Zero Sysman temperature properties.z2No Level Zero Sysman GPU temperature handle found.)rIrrPr5r,r(r)rrLzesDeviceEnumTemperatureSensorsrrnrzes_temp_handle_tzes_temp_properties_t"ZES_STRUCTURE_TYPE_TEMP_PROPERTIESrvzesTemperatureGetPropertiesrZES_TEMP_SENSORS_GPU onSubdevice subdeviceId) r=rerr(r) temp_count temp_handlesr, temp_handle temp_propss r!_get_zes_temperature_handler^&s OE v 5FV$ #F +D *&&&&&M$$L !J --mU:=NPTU?1LMM>E++j.>.>>AL -- 5,l  B # 002  CC   - -k5;L M A  ??e88 8   #%%**@*@L*P%0"))%0"!$!OPP0D r ct|}ddl}td}|j|t |}||j k(r t d||jk7rt d|d|jS)agReturn the GPU temperature in degrees Celsius. Args: device (torch.device, str or int, optional): selected device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). .. note:: This API may require elevated privileges (e.g. ``sudo``) to access GPU temperature information. rNgz\GPU temperature querying is not available. Try running with elevated privileges (e.g. sudo).z0Can't get Level Zero Sysman GPU temperature (rc=rN) r^rerzesTemperatureGetStaterZE_RESULT_ERROR_NOT_AVAILABLErr_rn)r=r,retemprcs r! temperaturercis5V< C=D  % %&8%+ FB U 0 00 j   U $ $$MbTQSTUU ::r ct}t|d}t|t|}|j |jS|j }t d}t|j|t|dd|jdk(r td|j|jz}t|j|t||d|d}||_|S)aReturn the Level Zero Sysman GPU frequency domain handle for the specified device. The result is cached in ``_ZesDeviceInfo.frequency_handle`` so that repeated calls skip domain enumeration. ``_cached_zes_device_infos`` is lazily populated on the first call. Args: device (torch.device, str or int, optional): target device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). TrNrz4Can't get Level Zero Sysman frequency domains count.z-No Level Zero Sysman frequency domains found.z5Can't get Level Zero Sysman frequency domain handles.) rIrrPr5r-r(rrLzesDeviceEnumFrequencyDomainsrrnrzes_freq_handle_t)r=rerr( freq_count freq_handlesr-s r!_get_zes_frequency_handleris OE v 5FV$ #F +D ($$$&&M!J ++M5;LdS>1JKK>E++j.>.>>AL ++ 5,l  @ $A,D r ct|}ddl}|j}|j|t |}||j k7rt d|d|jS)zReturn the GPU clock rate in MHz. Args: device (torch.device, str or int, optional): selected device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). rNz/Can't get Level Zero Sysman GPU clock rate (rc=rN)rirezes_freq_state_tzesFrequencyGetStaterr_ractual)r=r-re freq_statercs r! clock_raterosh18'')J  # #$4eJ6G HB U $ $$LRDPRSTT   r ct}t|d}t|t|}|j |jS|j }t d}t|j|t|dd|jdk(r td|j|jz}t|j|t||d|d}||_|S)aReturn the Level Zero Sysman GPU power domain handle for the specified device. The result is cached in ``_ZesDeviceInfo.power_handle`` so that repeated calls skip domain enumeration. ``_cached_zes_device_infos`` is lazily populated on the first call. Args: device (torch.device, str or int, optional): target device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). TrNrz0Can't get Level Zero Sysman power domains count.z)No Level Zero Sysman power domains found.z1Can't get Level Zero Sysman power domain handles.) rIrrPr5r.r(rrLzesDeviceEnumPowerDomainsrrnrzes_pwr_handle_t)r=rerr( power_count power_handlesr.s r!_get_zes_power_handlerus OE v 5FV$ #F +D $   &&M1+K '' u[7I4P:AFGG?U++k.?.??BM '' 5-}  < !#L$D r ct|}ddl}|j}|j|t |}||j k(r t d||jk7rt d|dddl}|jtdz |j}t|j|t |d|j|jz }|j|jz |z S)aReturn the GPU card power draw in watts. The value is computed by dividing the energy delta by the time delta between two energy-counter reads separated by a 100ms sampling interval. Args: device (torch.device, str or int, optional): selected device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). .. note:: This function blocks for approximately 100ms per call due to the sampling interval required to compute an accurate power reading. .. note:: This API may require elevated privileges (e.g. ``sudo``) to access GPU power information. rNz[GPU power draw querying is not available. Try running with elevated privileges (e.g. sudo).z/Can't get Level Zero Sysman GPU power draw (rc=rN@@z5Can't get Level Zero Sysman GPU power energy counter.)rurezes_power_energy_counter_tzesPowerGetEnergyCounterrrarr_timesleep_zes_sample_interval_msrL timestampenergy)r=r.re counter_startrcrz counter_enddts r! power_drawrs )0L446M  ' ' eM6J KB U 0 00 i   U $ $$LRDPRSTTJJ&/0224K &&|U;5GH?   !8!8 8B   !5!5 5 ;;r c :t}t|d}t|t|}|j |jS|j }|j }td}t|j|t|dd|jdk(r td|j|jz}t|j|t||dd}|D]}|j} |j| _t|j#|t| d| j$|j&k7rc|!| j(sr| j*|k(s|}n| j(r|}n| td ||_|S) aReturn the Level Zero Sysman GPU engine group handle for the specified device. The result is cached in ``_ZesDeviceInfo.engine_handle`` so that repeated calls skip group enumeration. ``_cached_zes_device_infos`` is lazily populated on the first call. Args: device (torch.device, str or int, optional): target device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). TrNrz/Can't get Level Zero Sysman engine group count.zNo Level Zero Sysman engine groups found. The GPU may not support engine monitoring, or try running with elevated privileges (e.g. sudo).z1Can't get Level Zero Sysman engine group handles.z.Can't get Level Zero Sysman engine properties.z-No Level Zero Sysman GPU engine handle found.)rIrrPr5r/r(r)rrLzesDeviceEnumEngineGroupsrrnrzes_engine_handle_tzes_engine_properties_t$ZES_STRUCTURE_TYPE_ENGINE_PROPERTIESrvzesEngineGetPropertiesrZES_ENGINE_GROUP_ALLrXrY) r=rerr(r) engine_countengine_handlesr/ eng_handle eng_propss r!_get_zes_engine_handlers OE v 5FV$ #F +D %!!!&&M$$LA;L '' u\7JDQ9 Q X  Ee//,2D2DDGN '' 5.  < M$ 113 DD   ( (U95E F <  >>U77 7   #$$)>)>,)N * (( * !$JKK&D r ct|}ddl}|j}|j|t |}||j k(r t d||jk7rt d|dddl}|jtdz |j}t|j|t |d|j|jz }|j|jz |z dzS) aReturn the GPU engine utilization as a percentage. The value is computed by dividing the active-time delta by the time delta between two engine-activity reads separated by a 100ms sampling interval. Args: device (torch.device, str or int, optional): selected device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). .. note:: This function blocks for approximately 100ms per call due to the sampling interval required to compute an accurate utilization reading. .. note:: This API may require elevated privileges (e.g. ``sudo``) to access GPU utilization information. rNz\GPU utilization querying is not available. Try running with elevated privileges (e.g. sudo).z4Can't get Level Zero Sysman GPU engine activity (rc=rNrwz0Can't get Level Zero Sysman GPU engine activity.d)rrezes_engine_stats_tzesEngineGetActivityrrarr_rzr{r|rLr} activeTime)r=r/re stats_startrcrz stats_endrs r! utilizationrds +62M**,K  # #M53E FB U 0 00 j   U $ $$B2$b I  JJ&/0((*I ""=% 2BC:   {44 4B  ;#9#9 9R ?# EEr c :t}t|d}t|t|}|j |jS|j }|j }td}t|j|t|dd|jdk(r td|j|jz}t|j|t||dd}|D]}|j} |j| _t|j#|t| d| j$|j&k7rc|!| j(sr| j*|k(s|}n| j(r|}n| td ||_|S) aReturn the Level Zero Sysman GPU memory module handle for the specified device. The result is cached in ``_ZesDeviceInfo.memory_handle`` so that repeated calls skip module enumeration. ``_cached_zes_device_infos`` is lazily populated on the first call. Args: device (torch.device, str or int, optional): target device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). TrNrz0Can't get Level Zero Sysman memory module count.z*No Level Zero Sysman memory modules found.z2Can't get Level Zero Sysman memory module handles..Can't get Level Zero Sysman memory properties.z-No Level Zero Sysman GPU memory handle found.)rIrrPr5r0r(r)rrLzesDeviceEnumMemoryModulesrrnrzes_mem_handle_tzes_mem_properties_t!ZES_STRUCTURE_TYPE_MEM_PROPERTIESrvzesMemoryGetPropertieslocationZES_MEM_LOC_DEVICErXrY) r=rerr(r) mem_countmemory_handlesr0 mem_handle mem_propss r!_zes_get_memory_handlers OE v 5FV$ #F +D %!!!&&M$$L I ((i8H$O:!GHH>e,,y>AN (( 5+^  = M$ ..0 AA   ( (U95E F <    !9!9 9   #$$)>)>,)N * (( * !$JKK&D r cTt|}ddl}|j}|j|t |}||j k(r t d||jk7rt d|dddl}|jtdz |j}t|j|t |d|j|jz }|j|jz }|j|jz } d|| zz|j|zz d zS) aReturn the GPU memory bandwidth usage as a percentage. The value is computed by dividing the byte-transfer delta by the time delta between two bandwidth-counter reads separated by a 100ms sampling interval, then normalizing by the peak bandwidth reported by the hardware. Args: device (torch.device, str or int, optional): selected device. Uses the current device, given by :func:`~torch.xpu.current_device`, if ``None`` (default). .. note:: This function blocks for approximately 100ms per call due to the sampling interval required to compute an accurate bandwidth reading. .. note:: This API may require elevated privileges (e.g. ``sudo``) to access GPU memory bandwidth usage information. rNzgGPU memory bandwidth usage querying is not available. Try running with elevated privileges (e.g. sudo).z5Can't get Level Zero Sysman GPU memory bandwidth (rc=rNrwz1Can't get Level Zero Sysman GPU memory bandwidth.g.Ar)rrezes_mem_bandwidth_tzesMemoryGetBandwidthrrarr_rzr{r|rLr} readCounter writeCounter maxBandwidth) r=r0rebandwidth_startrcrz bandwidth_endr read_delta write_deltas r! memory_usagers,"+62M//1O  $ $]E/4J KB U 0 00 u   U $ $$CB4r J  JJ&/0--/M ##M53GH;  ?#<#< > !!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_allrr set_rng_stateset_rng_state_all _POOL_HANDLE)?rrrrrr rrorrr#r=rrrrr2rrrr8rrrr+rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrstreamsr.rcr)rjr*)r=rPrjrP)F)rj list[int])r}rrjrP)rjrP)T)rr*rjr*r)r=rrjrr)r=rrjri)r=rrjzdict[str, Any])r=rrjr<)r=int | str | torch.devicerj torch.device)r=rr rrjr*)rrrjr)rrrjr)r=rrjr)r*rPr=rrjr)rjz list[str])rjri)r=rrjztorch._C.Generator)r)r@rPr=rrjr)r=rrjrP)rcrPrdrirjr)r=rP)r=rrjr)r=rrjr)r=rrjrP)r __future__r dataclassesrK threadingrr`ctypesrrrrrr functoolsr typingr r r r8torch._C torch._utilsrrcollections.abcr torch.typesr_utilsrgraphsrrrrrrrrrlocalrLockrrr4rr9rrr#r% dataclassr'r5r|r;r<_xpu_exchangeDevicerC_xpu_maybeExchangeDevicerFrYrrrrrrrrrrrrr=rrrrrrr r rrr"rrr+r.r2r8r:rBrErIrLrPr^rcrirorurrrrrrmemoryrrrrrrrrrrrrrrrrrrandomrrrrrrrrrrrPr__all__rr r!rs# EE.. 6("%# y%y~~'%(($6 F%'02-2#'j' ***24.3 > 8888xx33"XX>>''=>NN"Jv r0 22 U2 G%P  (   ( . 42+* +*+*\%  ; (3(3V! &$2 -= -5: 1 & * /  @F2,^&,^)B.Vb"F&   ~uS#X7 @ r