+ jDa0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIt^RI H t H t H t H t HtHt^RIHt^RIHtHtHt^RIt^RIt^RIHtHt]'d ^RIHt^RIHt^R IH t ^R I!H"t"H#t#H$t$H%t%H&t&^R I'H(t(H)t)R s*]PV!4t,]PZ!4t..s/R ]0R&]1!]PdRR4t3]!4s4Rt5R]0R&Rs6R]0R&]Pn!RR44t8.s9R]0R&^t:RRlt;];!4'dD]PdPxt<]PdPzt>]PdP~t@M]!R4tRRlt@RR R!lltAR"R#ltBR$R%ltCR&R'ltDR(R)ltER*R+ltFRR,R-lltGR.R/ltHR0tIR1R2ltJR3R4ltKR5R6ltL!R7R84tM!R9R:4tN!R;R<]N4tOR=R>ltPRR?R@lltQ]!R4RRARBll4tRRRCRDlltSRERFltTRGRHltURIRJltV!RKRL4tWRMRNltXRORPltYRQRRltZRRSRTllt[RRURVllt\RRWRXllt]RYRZlt^R[R\lt_R]R^lt`R_R`ltaRRaRblltbRRcRdlltcRetdRfRglteRhRiltfRjRkltgRRlRmllthRRnRolltiRRpRqlltjRRrRslltkRRtRulltlRRvRwlltmRRxRylltnRRzR{lltoRR|R}lltpRR~RlltqRRRlltr^RIsHtttHutuHvtvHwtwHxtxHytyHztzH{t{H|t|H}t}H~t~HtHtHtHtHtHtHt^RIHtHtHtHtHtHtHtHtHt]!R]]]3,4t.RNRNRLNRNRNRNRNRNRNRNRNR:NRr 0srztuple[torch._C.Generator]default_generators int | None_cached_device_countc]tRt^6t$R]R&RtR]R&RtR]R&RtR ]R &RtR ]R &Rt R ]R &Rt R ]R &Rt R ]R&Rt R#)_ZesDeviceInfor device_handleNr" subdevice_idFbool is_integratedzc_void_p | Nonetemperature_handlefrequency_handle power_handle engine_handle memory_handler) __name__ __module__ __qualname____firstlineno____annotations__r'r)r*r+r,r-r.__static_attributes__rrrr%r%6sP#L*#M4*..(,o,$(L/(%)M?)%)M?)rr%zlist[_ZesDeviceInfo]_cached_zes_device_infoscV^8dQhRR/#returnr(r)formats"r __annotate__r;Gsdrc6\PP#)z(Return true if compile with XPU support.)torch_C_has_xpurrr _is_compiledr@Gs 88  r_XpuDevicePropertiesc V^8dQhRRRR/#r8deviceintr9r)r:s"rr;r;TsNNNNrc\R4hz(PyTorch was compiled without XPU supportNotImplementedErrorrDs&r_exchange_devicerKT!"LMMrc V^8dQhRRRR/#rCr)r:s"rr;r;WsNNsNsNrc\R4hrGrHrJs&r_maybe_exchange_devicerOWrLrcV^8dQhRR/#)r8r9 list[int]r)r:s"rr;r;[s""I"rch\P!R4pVf\\^44#.pVP R4F?p\ VP 44pT^8gK&YB9gK.TPT4KA V# \d T'd\RT R24Rh.uu#i;i)aParse ``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'.) osgetenvlistrangesplitrEstrip ValueErrorappend)strictvarvisible_deviceselemxs& r_parse_visible_devicesrb[s ))& 'C {E#J!#O # DJJL!A 6a.  " "1 %   'dKTNK ups T ;'gT # \dR u#i;iuupi)aoEnumerate 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. Nc$V^8dQhRRRRRR/#)r8rcrEmsgstrr9r(r)r:s"rr;,_enum_zes_device_infos..__annotate__s!--C-c-d-rct<VSP8wd\P!V^R7VSP8g#)zQReturn True if the call failed (rc != ZE_RESULT_SUCCESS) after issuing a warning.) stacklevel)ZE_RESULT_SUCCESSwarningswarnrhripyzess&&r_zes_check_warn/_enum_zes_device_infos.._zes_check_warns0 (( ( MM#! ,U,,,,rz"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 handlesZE_FLAT_DEVICE_HIERARCHY COMPOSITEz-Can't get Level Zero Sysman device properties)r&r'r)) rr ExceptionzesInitr zesDriverGetrvaluezes_driver_handle_t zesDeviceGetzes_device_handle_trUrVr5clearsetzes_device_properties_t$ZES_STRUCTURE_TYPE_DEVICE_PROPERTIESstypezes_device_ext_properties_t(ZES_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIESrrrpNextzesDeviceGetPropertiesr(flags numSubdevicesrXr\r%r))rers driver_countdrivers device_countdevices#ZES_DEVICE_PROPERTY_FLAG_INTEGRATEDexpose_subdevicesvisible logical_indexnum_igpunum_dgpurDprops ext_propsr)tiled num_slotsslotinforrs& @r_enum_zes_device_infosrs. -- u}}Q')MNN A;L 5.52 Q((<+=+==@G 5.84 A;L 71:u\':DA2 ((<+=+==@G 71:u\':GD4 +1' "<=L""$,GMHH--/@@ 557 HH 79-x8   ( (u > ;  IY__/RRS "!SSe&9&9A&=SSBS+0E''a )$D'(//"&,-2T&3!MHMH Q M%'FH5$ 5TT=O=ODD5$     x{  t$ sL3MM3 MMc V^8dQhRRRR/#rdr)r:s"rr;r;s00 0c0rc\V4#)zRReturn the visible XPU device count via Level Zero Sysman, or negative on failure.)r)res&r_raw_device_count_zesrs !, //rcV^8dQhRR/#r8r9rEr)r:s"rr;r;s2232rc@\4pV'gR#\V4#)z;Return the number of visible XPU devices, or -1 on failure.rw)rbr)r_s r_device_count_zesrs,.O   11rcV^8dQhRR/#rr)r:s"rr;r;scrcF\4'g^#\e\#\'g\\R4'd \ P P4pM1\4pV^8d\ P P4MTp\'dVsV#)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. is_initializing) r@r# _initializedhasattr_tlsr=r>_xpu_getDeviceCountr)count zes_counts rrrsr >>'##|wt%677,,.%' 2;a-,,.Y|$ LrcV^8dQhRR/#r7r)r:s"rr;r;sdrc\4^8#)z7Return a bool indicating if XPU is currently available.)rrrr is_availablers >A rc V^8dQhRRRR/#)r8including_emulationr(r9r)r:s"rr;r;%s44rc\4'gR#T;'g)\PP4P#)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)rr=xpuget_device_propertieshas_bfloat16_conversions)rs&ris_bf16_supportedr%s6 >> F F 99 * * , E ErcV^8dQhRR/#r7r)r:s"rr;r;/sUU4Urcv\4'gR#\PP4P#)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)rr=rr'has_subgroup_matrix_multiply_accumulaterrris_tf32_supportedr/s' >> 99 * * , T TTrc<\;'d\4'*#)z8Return whether PyTorch's XPU state has been initialized.)r_is_in_bad_forkrrris_initializedr:s  1 1 111rcV^8dQhRR/#r8r9Noner)r:s"rr;r;?s K Kd Krc \;_uu_4\4'd V!4MVPRR4'd+\P V\ P !44MlVPRR4'd+\PV\ P !44M*\PV\ P !434RRR4R# +'giR#;i)seed_allFseedN) _initialization_lockrget_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrr\)callablekwargss&,r _lazy_callr?s      Jzz*e,,"11(I_lazy_init..nsX0NuRWUU0Ns  z5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )rrrrr RuntimeErrorr@AssertionErrorr=r> _xpu_initrrextendr get_callsrxrjjoindelattrr) queued_callorig_tracebackeris rrrWsC74):;;           I ~~ !FG G  $X0B0L0L0NXX -/<+ 0M0= D+ , C  2!0OPSTUPVxXBBD''.BYAZ\$C.a/ 0 D+ ,A   sNE(B E(! E-D4E8E( E ,E E EE%%E(( E9 c4]tRtRtRRltRtRRltRtR#) _DeviceGuardic V^8dQhRRRR/#)r8indexrEr9rr)r:s"rr;_DeviceGuard.__annotate__scdrc WnRVnR#Nrwidxprev_idx)selfrs&&r__init___DeviceGuard.__init__s rc b\PPVP4VnR#rr=rrKrrrs&r __enter___DeviceGuard.__enter__ 22488< rc$V^8dQhRRRRRR/#r8typer r{rr)r:s"rr;r!Src b\PPVP4VnR#rr=rrOrrrrr{rs&&&&r__exit___DeviceGuard.__exit__9933DMMBrrN)r/r0r1r2rrrr4rrrrrs=rrc8]tRtRtRtRRltRtRRltRtR #) rDizContext-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``. c V^8dQhRRRR/#)r8rDr r9rr)r:s"rr;device.__annotate__sstrc 8\VRR7VnRVnR#)ToptionalNrw)rrr)rrDs&&rrdevice.__init__s$Vd; rc b\PPVP4VnR#rrrs&rrdevice.__enter__rrc$V^8dQhRRRRRR/#rr)r:s"rr;rrrc b\PPVP4VnR#rrrs&&&&rrdevice.__exit__rrrN) r/r0r1r2__doc__rrrr4rrrrDrDs=rrDc2a]tRtRtRtRV3RlltRtV;t#) device_ofia Context-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. cV^8dQhRR/#rr)r:s"rr;device_of.__annotate__strc n<VP'dVP4MRp\SV` V4R#r)is_xpu get_devicesuperr)robjr __class__s&& rrdevice_of.__init__s&"%***cnn" rr)r/r0r1r2r rr4 __classcell__)rs@rrrsrrc V^8dQhRRRR/#r8rDrr9rr)r:s"rr;r;s ( (v ($ (rc\4\V4pV^8d"\PP V4R#R#)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. N)rrr=r>_xpu_setDevicerJs&r set_devicers1L v &F { 'rc V^8dQhRRRR/#)r8rDrr9rjr)r:s"rr;r;s . .F .c .rc,\V4P#)amGet 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 )rnamerJs&rget_device_namer"s ! ( - --rc V^8dQhRRRR/#)r8rDrr9zdict[str, Any]r)r:s"rr;r;s&Nrc $\V4p\\\\\ R4\ \\3p\V4Uu/uF<pVPR4'dK\\W4;qB4'gK:W4bK> up#uupi)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__) rrEfloatr(rjrrWtupledictdir startswith isinstancegetattr)rDrserializable_typeskeyr{s& rget_device_capabilityr/s} "& )EudCdT5$Ou: C~~d#  !44 J    sB &B B c V^8dQhRRRR/#)r8rDrr9rAr)r:s"rr;r;s+*+* +*+*rcF\4\VRR7p\V4#)a3 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_propertiesrJs&rrrs!RL v 5F !& ))rcV^8dQhRR/#rr)r:s"rr;r;s%%%rcR\4\PP4#)z0Return the index of a currently selected device.)rr=r>_xpu_getDevicerrrcurrent_devicer6sL 88 " " $$rc V^8dQhRRRR/#)r8rDint | str | torch.devicer9 torch.devicer)r:s"rr;r;s  0 \ rc\V\4'd\P!V4pV#\V\4'd\P!RV4pV#)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r)r+rjr=rDrErJs&r _get_devicer;sJ &#f% M FC eV, Mrc$V^8dQhRRRRRR/#)r8rDrpeerr9r(r)r:s"rr;r;%s! ; ;6 ; ;D ;rc\4\VRR7p\VRR7p\PP W4#)aQuery 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)rrr=r>_xpu_canDeviceAccessPeer)rDr=s&&rcan_device_access_peerr@%s6L v 5F TD 1D 88 , ,V ::rcD]tRtRt$RtR]R&RRltRtRR ltR t R #) StreamContexti5aContext-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 V^8dQhRRRR/#)r8streamrCr9rr)r:s"rr;StreamContext.__annotate__Cs64rc bWn\RR4VnVPf RVnR#R#)NTrw)rFrr)rrFs&&rrStreamContext.__init__Cs+ $T40 88 DH rc VPpVeVPR8XdR#\PP R4VnVP P VP 8wdU\ VP 4;_uu_4\PP VP 4VnRRR4\PPV4R# +'giL1;iNrw) rFrr=rcurrent_streamsrc_prev_streamrDdst_prev_stream set_stream)rrDs& rrStreamContext.__enter__Is[[  R $yy77=    & &**;*; ; ))**',yy'?'? @Q@Q'R$+ Z(+*s /C"" C2 c$V^8dQhRRRRRR/#rr)r:s"rr;rGUs!33S333rc :VPpVeVPR8XdR#VPPVP8wd*\P P VP4\P P VP4R#rK)rFrrMrDr=rrOrN)rrr{rrDs&&&& rrStreamContext.__exit__Usj[[  R     & &**;*; ; II !5!5 6 T112r)rNrrMrFN) r/r0r1r2r r3rrrr4rrrrBrB5s# (' )33rrBc V^8dQhRRRR/#)r8rFrCr9rBr)r:s"rr;r;`s!!*!}!rc\V4#)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``. )rBrFs&rrFrF`s   rcV^8dQhRR/#rr)r:s"rr;r;is  t rcJ\PPVVVR7R#)zset 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_setStreamrYs&&&r_set_stream_by_idr^is$ HH!rc V^8dQhRRRR/#)r8rFrr9rr)r:s"rr;r;wsv$rc~VfR#\4\VPVPVPR7R#)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``. NrY)rr^rZr[r\rVs&rrOrOws4~L""((&&rc V^8dQhRRRR/#)r8rDrr9rr)r:s"rr;r;s6Vrc\4\PP\ VRR74p\ V^,V^,V^,R7#)a: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.xpu.current_device`, if :attr:`device` is ``None`` (default). TrrY)rr=r>_xpu_getCurrentStreamrr)rD streamdatas& rrLrLsJL//&40J Q-jmTU rc$V^8dQhRRRRRR/#)r8data_ptrrErDrr9rr)r:s"rr;r;s!sFfrc\4\PPV\ VRR74p\ V^,V^,V^,R7#)aReturn 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. TrrY)rr=r>_xpu_getStreamFromExternalrr)rfrDrds&& rget_stream_from_externalrisM L44#FT:J Q-jmTU rc V^8dQhRRRR/#rr)r:s"rr;r;s - - -$ -rcn\4\VRR7p\PP V4#)aWait 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)rrr=r>_xpu_synchronizerJs&r synchronizerms*L v 5F 88 $ $V ,,rc V^8dQhRRRR/#)r8cyclesrEr9rr)r:s"rr;r;s   3  4  rcD\PPV4R#)aSpin the current XPU device for the given number of device clock cycles. The kernel is enqueued on the current stream and returns immediately on the host; the device-side spin runs asynchronously. Args: cycles (int): number of device clock cycles to spin. N)r=r> _xpu_sleep)ros&r_sleeprrs HHrcV^8dQhRR/#)r8r9z list[str]r)r:s"rr;r;syrc\4'g.#\PP4pVf.#VP 4#)z_xpu_getArchFlagsrY) arch_flagss r get_arch_listrws: >> ++-J    rcV^8dQhRR/#)r8r9rjr)r:s"rr;r;s==3=rcp\4p\V4^8XdR#RRPRV44 2#)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rz-device rTc3$"TFqxK R#5irr)rarchs& rr$get_gencode_flags..s: t s)rwlenr) arch_lists rget_gencode_flagsrs5I 9~ chh: ::; < -rcxVPpVf \4p\PPV,#)ziReturn the XPU Generator object for the given device. Args: device (torch.device): selected device. )rr6r=rr!)rDrs& r_get_generatorrs/ ,,C { 99 ' ' ,,rc$V^8dQhRRRRRR/#)r8offsetrErDr8r9rr)r:s"rr;r;s$ 1 rcJaa\V4oRVV3Rllp\V4R#)aSet the random number generator state offset of the specified GPU. Args: offset (int): The desired offset device (torch.device or int, optional): The device to set the RNG state. Default: ``'xpu'`` (i.e., ``torch.device('xpu')``, the current XPU device). cV^8dQhRR/#rr)r:s"rr;+_set_rng_state_offset..__annotate__s---rc@<\S4pVPS4R#r)r set_offset)default_generator final_devicers rcb!_set_rng_state_offset..cbs*<8$$V,rN)r;r)rrDrrsf& @r_set_rng_state_offsetrs"v&L--rNrc V^8dQhRRRR/#)r8rDr8r9rEr)r:s"rr;r;s * *": *s *rcb\4\V4p\V4pVP4#)a4Return 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)rDrrs& r_get_rng_state_offsetrs-Lv&L&|4  ' ' ))rcz^RIpV# \d\R4Rh\dp\R4ThRp?ii;i)znReturn the imported pyzes module; raise ImportError if missing, RuntimeError if the GPU driver is unavailable.Nz7pyzes is required; install it with 'pip install pyzes'.zZFailed to import pyzes. Ensure the GPU driver is installed with Level Zero Sysman support.)rr ImportErrorrxr)rrerrs r _import_pyzesrsS  L  E    h  s:: 5:cV^8dQhRR/#)r8r9ztuple[int, ...]r)r:s"rr;r;s88O8rcj^RIHp\\\V!R4P R444#)z Return the version of the pyzes package as a tuple of integers (major, minor, patch). Always ensure that the pyzes package is installed before calling this function. versionrr.)importlib.metadatarr'maprErYrs r_get_pyzes_versionrs) + S''*0056 77rc$V^8dQhRRRRRR/#)r8rhrErirjr9rr)r:s"rr;r;(s!//3/S/T/rcP^RIpWP8wd\V RV R24hR#)zRRaise RuntimeError if the Level Zero Sysman call failed (rc != ZE_RESULT_SUCCESS).Nz (rc=))rrrnrrqs&& r _zes_checkr(s. $ $$cU%t1-..%rcV^8dQhRR/#)r8rDrEr)r:s"rr;r;0s   S  rc\'g&\\RR74^8d \R4h\ \4pW8d\RV RV R24hR#)zLEnsure the ZES device info cache is populated and validate the device index.T)r]z2Failed 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)r5rrbrr})rD total_devicess& r_zes_ensure_device_infosr0s` # # !"8"E F JST T01M &!efsettv w  rc V^8dQhRRRR/#r8rDrr9rr)r:s"rr;r;=s@@@(@rc \4p\VRR7p\V4\V,pVPe VP#VP pVP p\^4p\VPV\V4R4R4VP^8Xd \R4hVPVP,!4p\VPV\V4V4R4RpVFpVP4p VPV n\VP#V\V 44R4V P$VP&8wdKfVe,V P('dV P*V8XdTpMKKV P('dKTpM Vf \R4hWrnV#) 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). TrNz5Can'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.)rrrr5r*r&r'rrzesDeviceEnumTemperatureSensorsrr{rzes_temp_handle_tzes_temp_properties_t"ZES_STRUCTURE_TYPE_TEMP_PROPERTIESrzesTemperatureGetPropertiesrZES_TEMP_SENSORS_GPU onSubdevice subdeviceId) rDrrrr&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++j.>.>>AL -- 5,l  B # 002  CC   - -k5;L M A  ??e88 8   #%%%**@*@L*P%0"+Q%)))%0"!$$!OPP0 rc V^8dQhRRRR/#r8rDrr9r&r)r:s"rr;r;s%rc\V4p^RIp\R4pVPV\ V44pWBP 8Xd \ R4hWBP8wd\ RV R24hVP#)aOReturn 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. Ngz\GPU temperature querying is not available. Try running with elevated privileges (e.g. sudo).z0Can't get Level Zero Sysman GPU temperature (rc=r) rrrrzesTemperatureGetStaterZE_RESULT_ERROR_NOT_AVAILABLErrnr{)rDr*rrtemprhs& r temperaturers|5V< C=D  % %&8%+ FB 0 00 j   $ $$MbTQSTUU ::rc V^8dQhRRRR/#rr)r:s"rr;r;sCCfCCrc \4p\VRR7p\V4\V,pVPe VP#VP pVP p\^4p\VPV\V4R4R4VP^8Xd \R4hVPVP,!4p\VPV\V4V4R4\4R 8dV^,pWrnV#RpVFpVP4p VP V n\VP%V\V 44R4V P&VP(8wdKfVe,V P*'dV P,V8XdTpMKKV P*'dKTpM Vf \R4hWrnV#) 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). TrNz4Can'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.z1Can't get Level Zero Sysman frequency properties.z0No Level Zero Sysman GPU frequency handle found.rr8)rrrr5r+r&r'rrzesDeviceEnumFrequencyDomainsrr{rzes_freq_handle_trzes_freq_properties_t"ZES_STRUCTURE_TYPE_FREQ_PROPERTIESrzesFrequencyGetPropertiesrZES_FREQ_DOMAIN_GPUrr) rDrrrr&r' freq_count freq_handlesr+ freq_handle freq_propss & r_get_zes_frequency_handlers OE v 5FV$ #F +D ($$$&&M$$L!J ++M5;LdS>1JKK++j.>.>>AL ++ 5,l  @ i''? 0# 002  CC   + +Kz9J K ?  ??e77 7   #%%%**@*@L*P#. +Q%)))#. !$$MNN, rc V^8dQhRRRR/#rr)r:s"rr;r;svrc\V4p^RIpVP4pVPV\ V44pWBP 8wd\ RV R24hVP#)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). Nz/Can't get Level Zero Sysman GPU clock rate (rc=r)rrrzes_freq_state_tzesFrequencyGetStaterrnractual)rDr+rr freq_staterhs& r clock_ratersf18'')J  # #$4eJ6G HB $ $$LRDPRSTT   rc V^8dQhRRRR/#rr)r:s"rr;r;sKK&KHKrc \4p\VRR7p\V4\V,pVPe VP#VP pVP p\^4p\VPV\V4R4R4VP^8Xd \R4hVPVP,!4p\VPV\V4V4R4\4R 8dV^,pWrnV#RpVEF2pVP4p VP V nVP%4p VP&V n\)\+V 4\,4V n\VP1V\V 44R4V P2VP4VP639dKVeIV P8'd5V P:V8Xd"TpV P2VP48XdM?KKKV P8'dEKTpV P2VP48XgEK3M Vf \R4hWrnV#) 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). TrNz0Can'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.z-Can't get Level Zero Sysman power properties.z,No Level Zero Sysman GPU power handle found.r)rrrr5r,r&r'rrzesDeviceEnumPowerDomainsrr{rzes_pwr_handle_trzes_power_properties_t#ZES_STRUCTURE_TYPE_POWER_PROPERTIESrzes_power_ext_properties_t'ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIESrrrrzesPowerGetPropertiesdomainZES_POWER_DOMAIN_CARDZES_POWER_DOMAIN_PACKAGErr) rDrrrr&r' power_count power_handlesr, pwr_handle pwr_props ext_pwr_propss & r_get_zes_power_handlers< OE v 5FV$ #F +D $   &&M$$L1+K '' u[7I4P:AFGG++k.?.??BM '' 5-}  < i'$Q' (L# 002 CC 88: #KK w}5x@   ' ' E)4D E ;      ' '  * *(     #$$$)>)>,)N)  ''5+F+FFG*O$ ((()  ''5+F+FF1$4IJJ$ rc V^8dQhRRRR/#rr)r:s"rr;r;@s,<,>U77 7   #$$$)>)>,)N * *O$((( * !%$JKK& rc V^8dQhRRRR/#rr)r:s"rr;r;s*F*F*F%*Frc$\V4p^RIpVP4pVPV\ V44pWBP 8Xd \ R4hWBP8wd\ RV R24h^RIpVP\R, 4VP4p\VPV\ V44R4VPVP, pVPVP, V, ^d,#)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. Nz\GPU utilization querying is not available. Try running with elevated privileges (e.g. sudo).z4Can't get Level Zero Sysman GPU engine activity (rc=rrz0Can't get Level Zero Sysman GPU engine activity.)rrrzes_engine_stats_tzesEngineGetActivityrrrrnrrrrr activeTime)rDr-rr stats_startrhr stats_endrs& r utilizationr s +62M**,K  # #M53E FB 0 00 j   $ $$B2$b I  JJ&/0((*I ""=% 2BC:   {44 4B  ;#9#9 9R ?# EErc V^8dQhRRRR/#rr)r:s"rr;r;s>>6>X>rc \4p\VRR7p\V4\V,pVPe VP#VP pVP p\^4p\VPV\V4R4R4VP^8Xd \R4hVPVP,!4p\VPV\V4V4R4RpVFpVP4p VPV n\VP#V\V 44R4V P$VP&8wdKfVe,V P('dV P*V8XdTpMKKV P('dKTpM Vf \R4hWrnV#) 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). TrNz0Can'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.)rrrr5r.r&r'rrzesDeviceEnumMemoryModulesrr{rzes_mem_handle_tzes_mem_properties_t!ZES_STRUCTURE_TYPE_MEM_PROPERTIESrzesMemoryGetPropertieslocationZES_MEM_LOC_DEVICErr) rDrrrr&r' mem_countmemory_handlesr. mem_handle mem_propss & r_zes_get_memory_handlers OE v 5FV$ #F +D %!!!&&M$$L I ((i8H$O:!GHH,,y>AN (( 5+^  = M$ ..0 AA   ( (U95E F <    !9!9 9   #$$$)>)>,)N * *O$((( * !%$JKK& rc V^8dQhRRRR/#rr)r:s"rr;r;"s.V.V.V5.Vrc\V4p^RIpVP4pVPV\ V44pWBP 8Xd \ R4hWBP8wd\ RV R24h^RIpVP\R, 4VP4p\VPV\ V44R4VPVP, pVPVP, pVPVP, p RW,,VPV,, ^d,#)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. NzgGPU 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=rrz1Can't get Level Zero Sysman GPU memory bandwidth.g.A)rrrzes_mem_bandwidth_tzesMemoryGetBandwidthrrrrnrrrrr readCounter writeCounter maxBandwidth) rDr.rrbandwidth_startrhr bandwidth_endr read_delta write_deltas & r memory_usager$"s&"+62M//1O  $ $]E/4J KB 0 00 u   $ $$CB4r J  JJ&/0--/M ##M53GH;  ?#<#< > !!r)change_current_allocator empty_cacheget_per_process_memory_fractionlist_gpu_processesmax_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_HANDLErrr@rr@r/rr6rLrr.r0rwr/r"rrr1rArBrirrrrCrrrrrr2rrDrEr3r4r5r6r7r8r9r:r$r;rr?r<r=rrrr>rFrGrOrFstreamsrmrr rr)Tr)r)__conditional_annotations__r  __future__r dataclassesrU threadingrroctypesrrrrrr functoolsr typingr r r r=torch._C torch._utilsr rcollections.abcr torch.typesr_utilsrgraphsrrrrrrIrrrlocalrLockrrr3r,r>rrr!r# dataclassr%r5rr@rA_xpu_exchangeDevicerK_xpu_maybeExchangeDevicerOrbrrrrrrrrrrrrrDrrr"r/rr6r;r@rBrFr^rOrLrirmrrrwrrrrrrrrrrrrrrrr rr$r.memoryr/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@randomrArBrCrDrErrrFrGr'rErH__all__)rJs@rr_s# EE.. 6("%#  ~~'%(($6 F%'02-2#'j' ***24.3 >> 8888xx33"XX>>''=>NN"Jv r0 22 U2 K%P  (   ( . 40+*\%  ; (3(3V! &$2 -  = -& * 8/  @F2CL&K\,<^BJ*FZ>B.Vb"F(   ~uS#X7 A  A  A A  A   A   A A A A A A  A A A A  !A "#A $%A &'A ()A *+A ,&-A ./A 01A 23A 4 5A 67A 8 9A :;A <=A >?A @"AA BCA DEA FGA HIA JKA LMA NOA PQA RSA TUA VWA XYA Z[A \"]A ^_A `aA bcA deA f%gA hiA j kA lmA noA p&qA rsA tuA vwA x yA z{A |}A ~A @AA r