"EiT%SrSSKrSSKrSSKJr SSKJr SSKJrJ r J r SSK r SSK r SSK JrJr SSKJr SS KJr SS KJrJrJrJrJr SS KJrJr S q\R<"5r\R@"5r!/q"\#\$\/S4\#\%4\&S '\'"\ RPSS5r)\"5q*Sr+\$\ RPRX\&S'S\-4Sjr.\."5(aC\ RPR^r/\ RPR`r1\ RPRdr3O\"S5r/S\4S\44Sjr1S\4S\44Sjr3\"SS9S\44Sj5r5S\-4Sjr6SDS\-S\-4Sjjr7S\-4Sjr8Sr9SESjr:SES jr;SES!jr<"S"S#5r="S$S5r>"S%S&\>5r?S\SS4S'jr@SFS\S\%4S(jjrA\"S5SFS\S\B\%\44S)jj5rCSFS\S\/4S*jjrDS\44S+jrES\4\%-\ R|-S\ R|4S,jrFS\S-\S\-4S.jrG"S/S05rHS1\ S2S\H4S3jrISES4jrJS1\SS4S5jrKSFS\S\4S6jjrLSFS7\4S\S\4S8jjrMSFS\SS4S9jjrNS\#\%4S:jrOS\%4S;jrPS\ R|S\ RPRX4S<jrQSGS=\4S\4\%-\ R|-SS4S>jjrRSGS\4\%-\ R|-S\44S?jjrSSS@KTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrbJcrcJdrdJere SSAKfJgrgJhrhJiriJjrjJkrkJlrlJmrmJnrnJoro \ "SB\$\4\445rp/SCQrqg)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)AnyNewTypeOptional) _dummy_type_LazySeedTracker)Device)_get_device_index)graphgraph_pool_handleis_current_stream_capturingmake_graphed_callablesXPUGraph)EventStreamF _queued_calls_xpu_isInBadForkcgNFrO/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/xpu/__init__.pyr&srrdefault_generatorsreturnc6[RR$)z(Return true if compile with XPU support.)torch_C_has_xpurrr _is_compiledr"+s 88  r_XpuDevicePropertiesdevicec[S5eNz(PyTorch was compiled without XPU supportNotImplementedErrorr$s r_exchange_devicer*8!"LMMrc[S5er&r'r)s r_maybe_exchange_devicer-;r+r)maxsizec^[5(dg[RR5$)z*Return the number of XPU device available.r)r"rr _xpu_getDeviceCountrrr device_countr1?s! >> 88 ' ' ))rc[5S:$)z7Return a bool indicating if XPU is currently available.r)r1rrr is_availabler3Gs >A rincluding_emulationc[5(dgU=(d( [RR5R$)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r3rxpuget_device_propertieshas_bfloat16_conversions)r4s ris_bf16_supportedr9Ms0 >> F 99 * * , E Ercr[5(dg[RR5R$)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)r3rr6r7'has_subgroup_matrix_multiply_accumulaterrris_tf32_supportedr<Ws' >> 99 * * , T TTrc:[=(a [5(+$)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrris_initializedr@bs  1 111rc [5(aU"5 gURSS5(a*[RU[R "55 gURSS5(a*[R U[R "55 g[RU[R "545 g)Nseed_allFseed) r@get_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrappend)callablekwargss r _lazy_callrMgs  ::j% ( (  - -h 8N8N8P Q ZZ & &  ) )(I4J4J4L M  (I,B,B,D!E Frc[5 g)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_initrrrinitrPus Lrc [5(d[[S5(ag[ [5(a SSS5 g[ 5(a [ S5e[ 5(d [S5e[RR5 S[l [RS[R555 [H upU"5 M ['[S5 SqSSS5 g![ a1nS[#U5SSR%U53n[!U5UeSnAff=f!['[S5 f=f!,(df  g=f) 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 enabledTc36# UHo(dM Uv M g7fNr).0callss r _lazy_init..sX0NuRWUU0Ns  z5XPU 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 rrOrO~s=74):;;          I ~~ !FG G  $X0B0L0L0NXX -/<+ 0M0= D+ , C  2!0OPSTUPVxXBBD''.BYAZ\$C.a/ 0 D+ ,A  sNEB E ED%E)E D?,D::D??EEE E%cB\rSrSrS\SS4SjrSrS\S\S \4S jrS r g) _DeviceGuardindexrNcXlSUlgNidxprev_idx)selfrms r__init___DeviceGuard.__init__s rc`[RRUR5UlgrTrr6r*rrrsrts r __enter___DeviceGuard.__enter__ 22488< rtypevaluerGc`[RRUR5Ulgrrr6r-rsrrrtr}r~rGs r__exit___DeviceGuard.__exit__9933DMMBrrq) __name__ __module__ __qualname____firstlineno__intrurzrr__static_attributes__rrrrkrks4cd=SrrkcF\rSrSrSrS\SS4SjrSrS\S\S \4S jrS r g) 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``. rNc0[USS9UlSUlg)NToptionalrp)r rrrs)rtr$s rrudevice.__init__s$Vd; rc`[RRUR5UlgrTrxrys rrzdevice.__enter__r|rr}r~rGc`[RRUR5Ulgrrrs rrdevice.__exit__rrrq) rrrr__doc__rrurzrrrrrr$r$s9st=Src0^\rSrSrSrSU4SjjrSrU=r$) device_ofa 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. cj>UR(aUR5OSn[TU] U5 gro)is_xpu get_devicesuperru)rtobjrr __class__s rrudevice_of.__init__s$"%**cnn" rrrN)rrrrrrur __classcell__)rs@rrrsrrcz[5 [U5nUS:a [RR U5 gg)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,[U5R$)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 )r7namer)s rget_device_namers ! ( - --rc "[U5n[[[[[ S5[ [[4n[U5Vs0sH:nURS5(aM[[X5=oB5(dM8X4_M< sn$s snf)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__) r7rfloatboolrcr}listtupledictdir startswith isinstancegetattr)r$propsserializable_typeskeyr~s rget_device_capabilityrs} "& )EudCdT5$Ou: C~~d#  !44 J    sB &B B c@[5 [USS9n[U5$)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. - ``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 rr7r7 s!JL v 5F !& ))rcR[5 [RR5$)z0Return the index of a currently selected device.)rOrr _xpu_getDevicerrrcurrent_devicer5sL 88 " " $$rc[U[5(a[R"U5nU$[U[5(a[R"SU5nU$)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. r6)rrcrr$rr)s r _get_devicer;sJ &#f% M FC eV, Mrpeerc|[5 [USS9n[USS9n[RR X5$)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)rOr rr _xpu_canDeviceAccessPeer)r$rs rcan_device_access_peerrHs6L v 5F TD 1D 88 , ,V ::rc^\rSrSr%Sr\S\S'S\SSS4SjrS rS \ S \ S \ 4S jr Sr g) StreamContextiXaContext-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\Xl[SS5UlURcSUlgg)NTrp)rr rr)rtrs rruStreamContext.__init__fs+ $T40 88 DH rcURnUbURS:Xag[RR S5UlUR R UR :waL[ UR 5 [RR UR 5UlSSS5 [RRU5 g!,(df  N.=fro) rrrrr6current_streamsrc_prev_streamr$dst_prev_stream set_stream)rtrs rrzStreamContext.__enter__ls[[  R $yy77=    & &**;*; ; ))*',yy'?'? @Q@Q'R$+ Z(+*s >/C C#r}r~rGc0URnUbURS:XagURRUR:wa)[R R UR5 [R R UR5 gro)rrrrr$rr6rr)rtr}r~rGrs rrStreamContext.__exit__xsj[[  R     & &**;*; ; II !5!5 6 T112r)rrrrr) rrrrrr__annotations__rurzrrrrrrrrXsM +,,x(:; )3S333rrrrc[U5$)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   rcB[RRUUUS9 g)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)rr _xpu_setStreamrs r_set_stream_by_idrs$ HH!rcrUcg[5 [URURURS9 g)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""((&&rc[5 [RR[ USS95n[ USUSUSS9$)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). Trrr r)rOrr _xpu_getCurrentStreamr r)r$ streamdatas rrrsJL//&40J Q-jmTU rdata_ptrc[5 [RRU[ USS95n[ USUSUSS9$)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. Trrr rr)rOrr _xpu_getStreamFromExternalr r)rr$rs rget_stream_from_externalrsM L44#FT:J Q-jmTU rch[5 [USS9n[RR U5$)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)rOr rr _xpu_synchronizer)s r synchronizers*L v 5F 88 $ $V ,,rc[5(d/$[RR5nUc/$UR 5$)z> ++-J    rcl[5n[U5S:XagSSRSU553$)zIReturn XPU AOT(ahead-of-time) build flags this library was compiled with.rrYz-device ,c3$# UHov M g7frTr)rUarchs rrW$get_gencode_flags..s: t s)rlenrd) arch_lists rget_gencode_flagsrs5I 9~ chh: ::; <>[T5nURT5 grT)r set_offset)default_generator final_devicers rcb!_set_rng_state_offset..cbs*<8$$V,rr)rrM)rr$rrs` @r_set_rng_state_offsetrs"v&L--rNrcb[5 [U5n[U5nUR5$)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. )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$rr1rrrrr7rrrrrr rrPrr3r9rr@r<rrrrrrrr r r r r rrrrCrBrrrrrrstreamsr)TrrT)r6)rr threadingrGcollections.abcr functoolsrtypingrrrrtorch._C torch._utilsrr torch.typesr _utilsr graphsr rrrrrrrr>localr[Lockr\rrrrcrrr r?rEr Generatorrr"r#_xpu_exchangeDevicer*_xpu_maybeExchangeDevicer-rr1r3r9r<r@rMrPrOrkr$rrrrrr7rrrrrrrrrrrrrrrmemoryrrrrrrrr r r r r rrrrrrandomrrrrrrCrBrrr__all__rrrr-s$)) 6%#  ~~'t (2t8 d3i '(%(($6 F%'02E%((,,-2d >> 8888xx33"XX>>''=>NNNNsNsN 1*c**d 44U4U2 G%P  (   (v ($ ( .F .c . 4&DcN2'* '*'*T%% c ELL0 U\\  ;6 ; ;D ; (3(3V!8./!M! v$&6V$sFf2 - -$ -tCy=3= -5<< -EHH,>,> -5: sU\\1 & *#)ell": *s *"&   ~uS#X7 : r