o kiT@s0UdZddlZddlZddlmZddlmZddlmZm Z m Z ddl Z ddl Z ddl mZmZddlmZdd lmZdd lmZmZmZmZmZdd lmZmZd aeZe Z!ga"e#e$egdfe#e%fe&d <e'e j(dddZ)ea*dZ+e$e j(j,e&d<de-fddZ.e.re j(j/Z/e j(j0Z1e j(j2Z3nedZ/de4de4fddZ1de4de4fddZ3eddde4fddZ5de-fdd Z6dcd"e-de-fd#d$Z7de-fd%d&Z8d'd(Z9ddd)d*Z:ddd+d,Z;ddd-d.ZGd2d3d3e>Z?deddfd4d5Z@dedede%fd6d7ZAeddededeBe%effd8d9ZC dedede/fd:d;ZDde4fdBde j>fd>d?ZFded@ede-fdAdBZGGdCdDdDZHdEe dFdeHfdGdEZIdddHdIZJdEeddfdJdKZKdededefdLdMZLdedNe4dedefdOdPZMdededdfdQdRZNde#e%fdSdTZOde%fdUdVZPde j>de j(j,fdWdXZQ YdfdZe4de4e%Be j>Bddfd[d\ZRdfde4e%Be j>Bde4fd]d^ZSdd_lTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZedd`lfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZoe dae$e4e4fZpgdbZqdS)gz 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_isInBadForkcCsdSNFrrr\/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/xpu/__init__.py&srrdefault_generatorsreturncCstjjS)z(Return true if compile with XPU support.)torch_C_has_xpurrrr _is_compiled+sr_XpuDevicePropertiesdevicecCtdNz(PyTorch was compiled without XPU supportNotImplementedErrorr rrr_exchange_device8r&cCr!r"r#r%rrr_maybe_exchange_device;r'r()maxsizecCstsdStjS)z*Return the number of XPU device available.r)rrr_xpu_getDeviceCountrrrr device_count?s r+cCs tdkS)z7Return a bool indicating if XPU is currently available.r)r+rrrr is_availableGs r,Tincluding_emulationcCstsdS|p tjjS)zKReturn a bool indicating if the current XPU device supports dtype bfloat16.F)r,rxpuget_device_propertieshas_bfloat16_conversions)r-rrris_bf16_supportedMs  r1cCstsdStjjS)zGReturn a bool indicating if the current XPU device supports dtype tf32.F)r,rr.r/'has_subgroup_matrix_multiply_accumulaterrrris_tf32_supportedWs r3cCs tot S)z8Return whether PyTorch's XPU state has been initialized.) _initialized_is_in_bad_forkrrrris_initializedbs r6cKsftr|dS|ddrt|tdS|ddr(t|tdSt|tfdS)Nseed_allFseed) r6get_lazy_seed_trackerqueue_seed_all traceback format_stack queue_seedrappend)callablekwargsrrr _lazy_callgs   rBcCs 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_initrrrrinitus rDc 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).0callsrrr sz_lazy_init..z5XPU call failed lazily at initialization with error: z' XPU call was originally invoked at: )r6hasattr_tls_initialization_lockr5 RuntimeErrorrAssertionErrorrr _xpu_initrErextendr: get_calls Exceptionstrjoindelattrr4) queued_callorig_tracebackemsgrrrrC~s>      "rCc@s<eZdZdeddfddZddZded ed efd d ZdS) _DeviceGuardindexrNcCs||_d|_dSN)idxprev_idx)selfr\rrr__init__s z_DeviceGuard.__init__cCtj|j|_dSrFrr.r&r_r`rarrr __enter__z_DeviceGuard.__enter__typevaluer<cCtj|j|_dSrrr.r(r`r_rarhrir<rrr__exit__z_DeviceGuard.__exit__)__name__ __module__ __qualname__intrbrfrrmrrrrr[sr[c@s@eZdZdZdeddfddZddZded ed efd d ZdS) 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``. rNcCst|dd|_d|_dS)NToptionalr^)r r_r`)rar rrrrbs zdevice.__init__cCrcrFrdrerrrrfrgzdevice.__enter__rhrir<cCrjrrkrlrrrrmrnzdevice.__exit__)rorprq__doc__rrbrfrmrrrrr s cs"eZdZdZdfdd ZZS) 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. rNcs"|jr|nd}t|dSr])is_xpu get_devicesuperrb)raobjr_ __class__rrrbszdevice_of.__init__rN)rorprqrurb __classcell__rrr{rrvs rvcCs*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)rCr rr_xpu_setDevicer%rrr set_devices rcCs 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 )r/namer%rrrget_device_names rcs:t|tttttdtttffddt DS)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 Ncs0i|]}|dstt|r|qS)__) startswith isinstancegetattr)rGkeypropsserializable_typesrirr sz)get_device_capability..) r/rrfloatboolrTrhlisttupledictdirr%rrrget_device_capabilitys rcCstt|dd}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. - ``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 Trs)rCr _get_device_propertiesr%rrrr/ s% r/cCsttjS)z0Return the index of a currently selected device.)rCrr_xpu_getDevicerrrrcurrent_device5s rcCs2t|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. r.)rrTrr rrr%rrr _get_device;s   rpeercCs,tt|dd}t|dd}tj||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. Trs)rCr rr_xpu_canDeviceAccessPeer)r rrrrcan_device_access_peerHs  rc@sReZdZUdZeded<dedddfddZd d Zd ed ed efddZ 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_streamstreamrNcCs*||_tdd|_|jdurd|_dSdS)NTr^)rr r_)rarrrrrbfs    zStreamContext.__init__cCs|j}|dus |jdkrdStjd|_|jj|jkr9t|jtj|j|_Wdn1s4wYtj|dSr]) rr_rr.current_streamsrc_prev_streamr dst_prev_stream set_stream)rarrrrrfls zStreamContext.__enter__rhrir<cCsJ|j}|dus |jdkrdS|jj|jkrtj|jtj|jdSr])rr_rr rr.rr)rarhrir<rrrrrmxs zStreamContext.__exit__) rorprqrur__annotations__rbrfrrmrrrrrXs   rrrcCst|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``. )rrrrrrscCstjj|||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)rr_xpu_setStreamrrrr_set_stream_by_ids  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)rCrrrrrrrrrs  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). Trsrr r)rCrr_xpu_getCurrentStreamr r)r streamdatarrrrs  rdata_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. Trsrr rr)rCrr_xpu_getStreamFromExternalr r)rr rrrrget_stream_from_externals 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). Trs)rCr rr_xpu_synchronizer%rrr synchronizes  rcCs(tsgStj}|durgS|S)z.)rlenrU) 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)r\rrr.r)r r_rrr_get_generators rr.offsetcs$t|dfdd }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). rNcst}|dSrF)r set_offset)default_generator final_devicerrrcbsz!_set_rng_state_offset..cbr})rrB)rr rrrr_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. )rCrr get_offset)r rrrrr_get_rng_state_offsets 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_allr8r7 set_rng_stateset_rng_state_all _POOL_HANDLE)9rrrrrrrrrrr rvr+rrrrr/rrrrrr r rDrr,r1rr6r3rrrrrrrrrrrrrrrr8r7rrrrrrstreamsr)Tr}rF)r.)rru threadingr<collections.abcr functoolsrtypingrrrrtorch._C torch._utilsrr torch.typesr _utilsr graphsr r rrrrrrr4localrLLockrMrrrrTrrrr5r:r Generatorrrr_xpu_exchangeDevicer&_xpu_maybeExchangeDevicer(rrr+r,r1r3r6rBrDrCr[r rvrrrrr/rrrrrrrrrrrrrrrmemoryrrrrrrrrrrrrrrrrrrandomrrrrrr8r7rrr__all__rrrrs         (   * +      L,