o vZhVE@sUdZddlZddlZddlmZddlmZmZmZm Z ddl Z ddl Z ddl m Z ddlmZmZddlmZdd lmZmZd aeZeZgaeeegdfeefed <e e j!d d dZ"e e ee#dfZ$ea%dZ&ee j!j'ed<de(fddZ)e)re j!j*Z*e j!j+Z,e j!j-Z.nedZ*de#de#fddZ,de#de#fddZ.eddde#fddZ/de(fddZ0dd Z1d!d"Z2d#d$Z3d%d&Z4d'd(Z5Gd)d*d*Z6Gd+ddZ Gd,d-d-e Z7de$ddfd.d/Z8dYdee$defd0d1Z9eddYdee$de:eeffd2d3Z;dYdee$de*fd4d5ZGd:d;d;Z?dd<Z@d?d@ZAdsrrdefault_generatorsreturncCstjjS)z(Return true if compile with XPU support.)torch_CZ_has_xpurrrr _is_compiled#sr_XpuDevicePropertiesrcCtdNz(PyTorch was compiled without XPU supportNotImplementedErrorrrrr_exchange_device0rcCrrrrrrr_maybe_exchange_device3r r!)maxsizecCstsdStjS)z*Return the number of XPU device available.r)rrrZ_xpu_getDeviceCountrrrr device_count7s r#cCs tdkS)z7Return a bool indicating if XPU is currently available.r)r#rrrr is_available?s r$cCr)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.Trrrrris_bf16_supportedEsr%cCs tot S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrrris_initializedJs r(cKsftr|dS|ddrt|tdS|ddr(t|tdSt|tfdS)Nseed_allFseed) r(get_lazy_seed_trackerZqueue_seed_all traceback format_stackZ queue_seedrappend)callablekwargsrrr _lazy_callOs   r2cCs 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_initrrrrinit]s r4c Cststtdr dStqtr WddStr tdts'tdtj dt_ t ddtDz1t D]'\}}z|Wq>tye}zdt|dd |}t||d}~wwWttdnttdwdaWddS1swYdS) 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 enabledTcss|]}|r|VqdSNr).0Zcallsrrr }sz_lazy_init..z5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )r(hasattr_tls_initialization_lockr' RuntimeErrorrAssertionErrorrrZ _xpu_initr5rextendr,Z get_calls Exceptionstrjoindelattrr&)Z queued_callZorig_tracebackemsgrrrr3fs>      "r3c@s8eZdZdefddZddZdededefd d Zd S) _DeviceGuardindexcCs||_d|_dSN)idxprev_idx)selfrGrrr__init__s z_DeviceGuard.__init__cCtj|j|_dSr6rxpurrJrKrLrrr __enter__z_DeviceGuard.__enter__typevaluer-cCtj|j|_dSrrrPr!rKrJrLrTrUr-rrr__exit__z_DeviceGuard.__exit__N)__name__ __module__ __qualname__intrMrRrrYrrrrrFsrFc@s<eZdZdZdefddZddZdededefd d Zd S) rzContext-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``. cCst|dd|_d|_dS)NToptionalrI)r rJrK)rLrrrrrMs zdevice.__init__cCrNr6rOrQrrrrRrSzdevice.__enter__rTrUr-cCrVrrWrXrrrrYrZzdevice.__exit__N)r[r\r]__doc__rrMrRrYrrrrrs cs eZdZdZfddZZS) 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. cs"|jr|nd}t|dSrH)Zis_xpuZ get_devicesuperrM)rLobjrJ __class__rrrMszdevice_of.__init__)r[r\r]rarM __classcell__rrrerrbs rbcCs*tt|}|dkrtj|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)r3r rrZ_xpu_setDevicerrrr set_devices rhcCs 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 )get_device_propertiesnamerrrrget_device_names rkcst|fddtDS)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 cs"i|] }|ds|t|qS))__Z _pybind11_) startswithgetattr)r7proppropsrr s  z)get_device_capability..)ridirrrrprget_device_capabilitys rtcCstt|dd}t|S)zGet the properties of a device. 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_)r3r Z_get_device_propertiesrrrrris ricCsttjS)z0Return the index of a currently selected device.)r3rrZ_xpu_getDevicerrrrcurrent_devices rucCs2t|tr t|}|St|trtd|}|S)zReturn the torch.device type object from the passed in device. Args: device (torch.device or int or str): selected device. rP) isinstancerArrr^rrrr _get_device s   rwc@sNeZdZUdZeded<dedfddZddZd ed ed efd d Z dS) 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 cur_streamstreamcCs*||_tdd|_|jdurd|_dSdS)NTrI)r{r rJ)rLr{rrrrM$s    zStreamContext.__init__cCs|j}|dus |jdkrdStjd|_|jj|jkr9t|jtj|j|_Wdn1s4wYtj|dSrH) r{rJrrPcurrent_streamsrc_prev_streamrdst_prev_stream set_stream)rLrzrrrrR*s zStreamContext.__enter__rTrUr-cCsJ|j}|dus |jdkrdS|jj|jkrtj|jtj|jdSrH)r{rJr}rrrPrr~)rLrTrUr-rzrrrrY6s zStreamContext.__exit__N) r[r\r]rar__annotations__rMrRrrYrrrrrxs   rxr{rycCst|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``. )rxr{rrrr{AscCstjj|||ddS)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)rrZ_xpu_setStreamrrrr_set_stream_by_idJs  rcCs*|durdStt|j|j|jddS)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)r3rrrrrrrrrXs  rcCs4ttjt|dd}t|d|d|ddS)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). Tr_rr r)r3rrZ_xpu_getCurrentStreamr r)r streamdatarrrr|ks  r|data_ptrcCs6ttj|t|dd}t|d|d|ddS)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. Tr_rr rr)r3rrZ_xpu_getStreamFromExternalr r)rrrrrrget_stream_from_external}s rcCstt|dd}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_)r3r rrZ_xpu_synchronizerrrr synchronizes  rcCs(tsgStj}|durgS|S)z.)rlenrB)Z arch_listrrrget_gencode_flagss rcCs |j}|dur t}tjj|S)zuReturn the XPU Generator object for the given device. Args: device (torch.device): selected device. N)rGrurrPr)rrJrrr_get_generators rrPoffsetcs"t|fdd}t|dS)a$Set 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). cst}|dSr6)rZ set_offset)default_generator final_devicerrrcbsz!_set_rng_state_offset..cbN)rwr2)rrrrrr_set_rng_state_offsets  rcCstt|}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. )r3rwrZ get_offset)rrrrrr_get_rng_state_offsets r) empty_cachemax_memory_allocatedmax_memory_reserved mem_get_infomemory_allocatedmemory_reserved memory_statsmemory_stats_as_nested_dictreset_accumulated_memory_statsreset_peak_memory_stats) get_rng_stateget_rng_state_all initial_seed manual_seedmanual_seed_allr*r) set_rng_stateset_rng_state_all)+r rrxrur|rrrbr#rrrtrkrirrrrr4rr$r%r(rrrrrrrrrrrr*r)rhrrrr{streamsrr6)rP)ara threadingr- functoolsrtypingrrrrrZtorch._CrZ_deviceZ torch._utilsr r _utilsr rr rr&localr;Lockr<rlisttuplerArrnrr'r^Z _device_tr,r GeneratorboolrrZ_xpu_exchangeDevicerZ_xpu_maybeExchangeDevicer!r#r$r%r(r2r4r3rFrbrhrkdictrtrirurwrxr{rrr|rrrrrrrZmemoryrrrrrrrrrrrandomrrrrrr*r)rr__all__rrrrs     (  "  *      0,