9jQ+dZddlmZddlmZddlmZddlZddlm Z m Z ddl m Z dd l mZmZmZmZmZmZmZmZmZmZgd Zd efd Zd efd Zdded ej:dzfdZd efdZede eZ!de!_ed de d e"e#effdZ$de d dfdZ%ede e%Z&de&_d de d ejNfdZ(dejNd dfdZ)d de d dfdZ*GddZ+y)!z] This package introduces support for the current :ref:`accelerator` in python. )cache)Any) deprecatedN) _device_t_get_device_index)Graph) empty_cacheempty_host_cacheget_memory_infomax_memory_allocatedmax_memory_reservedmemory_allocatedmemory_reserved memory_statsreset_accumulated_memory_statsreset_peak_memory_stats)r current_acceleratorcurrent_device_idxcurrent_device_indexget_device_capabilitycurrent_stream device_count device_indexr r r is_availabler rrrrrrset_device_idxset_device_index set_stream synchronizereturncft}|ytj|}|jS)aReturn the number of current :ref:`accelerator` available. Returns: int: the number of the current :ref:`accelerator` available. If there is no available accelerators, return 0. .. note:: This API delegates to the device-specific version of `device_count`. On CUDA, this API will NOT poison fork if NVML discovery succeeds. Otherwise, it will. For more details, see :ref:`multiprocessing-poison-fork-note`. r)rtorchget_device_moduleraccmods Z/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/accelerator/__init__.pyrr6s3  C {  ! !# &C    cft}|ytj|}|jS)aCheck if the current accelerator is available at runtime: it was build, all the required drivers are available and at least one device is visible. See :ref:`accelerator` for details. Returns: bool: A boolean indicating if there is an available :ref:`accelerator`. .. note:: This API delegates to the device-specific version of `is_available`. On CUDA, when the environment variable ``PYTORCH_NVML_BASED_CUDA_CHECK=1`` is set, this function will NOT poison fork. Otherwise, it will. For more details, see :ref:`multiprocessing-poison-fork-note`. Example:: >>> assert torch.accelerator.is_available() "No available accelerators detected." F)rr"r#rr$s r'rrIs3*  C {  ! !# &C    r(check_availablecdtjjx}|r |r tr|Sy)aJReturn the device of the accelerator available at compilation time. If no accelerator were available at compilation time, returns None. See :ref:`accelerator` for details. Args: check_available (bool, optional): if True, will also do a runtime check to see if the device :func:`torch.accelerator.is_available` on top of the compile-time check. Default: ``False`` Returns: torch.device: return the current accelerator as :class:`torch.device`. .. note:: The index of the returned :class:`torch.device` will be ``None``, please use :func:`torch.accelerator.current_device_index` to know the current index being used. This API does NOT poison fork. For more details, see :ref:`multiprocessing-poison-fork-note`. Example:: >>> # xdoctest: >>> # If an accelerator is available, sent the model to it >>> model = torch.nn.Linear(2, 2) >>> if (current_device := current_accelerator(check_available=True)) is not None: >>> model.to(current_device) N)r"_C_accelerator_getAcceleratorr)r*r%s r'rrfs-4xx3355B_J r(c>tjjS)zReturn the index of a currently selected device for the current :ref:`accelerator`. Returns: int: the index of a currently selected device. )r"r,_accelerator_getDeviceIndexr(r'rrs 88 / / 11r(z#Use `current_device_index` instead.)categorya (Deprecated) Return the index of a currently selected device for the current :ref:`accelerator`. Returns: int: the index of a currently selected device. .. warning:: :func:`torch.accelerator.current_device_idx` is deprecated in favor of :func:`torch.accelerator.current_device_index` and will be removed in a future PyTorch release. devicecZt|d}tjj|S)aReturn the capability of the currently selected device. Args: device (:class:`torch.device`, str, int, optional): The device to query capabilities for :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. Returns: dict[str, Any]: A dictionary containing device capability information. The dictionary includes: - ``supported_dtypes`` (set(torch.dtype)): Set of PyTorch data types for which tensors can be allocated on the accelerator and type conversion across supported dtypes are supported. Any operator support outside of that is not guaranteed Examples: >>> # xdoctest: +SKIP("requires cuda") >>> # Query capabilities for current device >>> capabilities = torch.accelerator.get_device_capability("cuda:0") >>> print("Supported dtypes:", capabilities["supported_dtypes"]) Toptional)rr"r, _accelerator_getDeviceCapabilityr2rs r'rrs%,%Vd;L 88 4 4\ BBr(c\t|d}tjj|y)a Set the current device index to a given device. Args: device (:class:`torch.device`, str, int): a given device that must match the current :ref:`accelerator` device type. .. note:: This function is a no-op if this device index is negative. Fr4N)rr"r,_accelerator_setDeviceIndexr7s r'rrs"%Ve` device type. .. warning:: :func:`torch.accelerator.set_device_idx` is deprecated in favor of :func:`torch.accelerator.set_device_index` and will be removed in a future PyTorch release. cZt|d}tjj|S)aReturn the currently selected stream for a given device. Args: device (:class:`torch.device`, str, int, optional): a given device that must match the current :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. Returns: torch.Stream: the currently selected stream for a given device. Tr4)rr"r,_accelerator_getStreamr7s r'rrs%%Vd;L 88 * *< 88r(streamcBtjj|y)aSet the current stream to a given stream. Args: stream (torch.Stream): a given stream that must match the current :ref:`accelerator` device type. .. note:: This function will set the current device index to the device index of the given stream. N)r"r,_accelerator_setStream)r<s r'rrs HH##F+r(c\t|d}tjj|y)aWait for all kernels in all streams on the given device to complete. Args: device (:class:`torch.device`, str, int, optional): device for which to synchronize. It must match the current :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. .. note:: This function is a no-op if the current :ref:`accelerator` is not initialized. Example:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA) >>> assert torch.accelerator.is_available() "No available accelerators detected." >>> start_event = torch.Event(enable_timing=True) >>> end_event = torch.Event(enable_timing=True) >>> start_event.record() >>> tensor = torch.randn(100, device=torch.accelerator.current_accelerator()) >>> sum = torch.sum(tensor) >>> end_event.record() >>> torch.accelerator.synchronize() >>> elapsed_time_ms = start_event.elapsed_time(end_event) Tr4N)rr"r,_accelerator_synchronizeDevicer7s r'rrs".%Vd;L HH++L9r(c>eZdZdZdedzddfdZd dZdeddfdZy) raContext manager to set the current device index for the current :ref:`accelerator`. Temporarily changes the current device index to the specified value for the duration of the context, and automatically restores the previous device index when exiting the context. Args: device (Optional[int]): a given device index to temporarily set. If None, no device index switching occurs. Examples: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA) >>> # Set device 0 as the current device temporarily >>> with torch.accelerator.device_index(0): ... # Code here runs with device 0 as the current device ... pass >>> # Original device is now restored >>> # No-op when None is passed >>> with torch.accelerator.device_index(None): ... # No device switching occurs ... pass r2Nr c ||_d|_y)N)idxprev_idx)selfr2s r'__init__zdevice_index.__init__)s r(cz|j/tjj|j|_yyN)rDr"r,_accelerator_exchangeDevicerE)rFs r' __enter__zdevice_index.__enter__-s+ 88 !HH@@JDM r(exc_infocp|j*tjj|jyyrI)rDr"r, _accelerator_maybeExchangeDevicerE)rFrLs r'__exit__zdevice_index.__exit__1s' 88  HH 5 5dmm D r()r N) __name__ __module__ __qualname____doc__intrGrKobjectrOr0r(r'rrs:.sTzKE&ETEr(r)FrI),rS functoolsrtypingrtyping_extensionsrr"_utilsrrgraphsr memoryr r r r rrrrrr__all__rTrboolrr2rr FutureWarningrdictstrrrrStreamrrrrr0r(r'rbsU( 0    6c&d:%,,:M@2c2Z)  C)C$sCx.CC4 7Y 7d 7%   99 95<< 9,u||,,: ::6"E"Er(