o * i@sxUddlmZddlZddlZddlZddlmZmZddlm Z ddl Z ddl m Z m Z ddlmZmZmZmZddlmZmZerdd lmZdd l mZmZdd lmZdd lmZee j e j!e j"fZ#ee j$e j%e j&fZ'dd l m(Z(m)Z)ddl*m+Z+ee(e)e,e-fZ.de/d<gdZ0da1dcddZ2ddddZ3deddZddddZ4dfd"d#Zdgd%d&Z5dhd)d*Z6did+d,Z7djd-d.Z8dkdld1d2Z9dmd4d5Z:dnd7d8Z;dmd9d:ZdpdBdCZ?dqdEdFZ@dkdrdGdHZAdkdrdIdJZBdkdsdKdLZCdkdsdMdNZDdkdrdOdPZEdkdrdQdRZFGdSdTdTZGGdUdVdVZHdkdtdXdYZIdud[d\ZJGd]d^d^ZKGd_d`d`ZLdkdvdadbZMdS)w) annotationsN) TYPE_CHECKINGUnion) TypeAlias)core framework)is_compiled_with_cinnis_compiled_with_cudais_compiled_with_distributeis_compiled_with_rocm)cudaxpu) TracebackType)IPUPlaceXPUPlace) PlaceLike)Place) CUDAPlace CustomPlace)_customDevicePropertiesr_CustomPlaceLike)get_cudnn_version set_device get_devicerris_compiled_with_xpuis_compiled_with_ipurr r r is_compiled_with_custom_deviceget_all_device_typeget_all_custom_device_typeget_available_deviceget_available_custom_deviceget_device_propertiesStreamEventcurrent_stream set_stream stream_guard device_guard synchronize device_typestrreturnboolcC t|S)a Whether paddle was built with Paddle_CUSTOM_DEVICE . Args: device_type (str): the registered device type, like "npu". Return: bool, ``True`` if CustomDevice is supported, otherwise ``False``. Examples: .. code-block:: python >>> import paddle >>> support_npu = paddle.device.is_compiled_with_custom_device("npu") )rr)r*r/b/home/app/PaddleOCR-VL-test/.venv_paddleocr/lib/python3.10/site-packages/paddle/device/__init__.pyr] rcCtS)a Whether paddle was built with WITH_IPU=ON to support Graphcore IPU. Returns (bool): `True` if IPU is supported, otherwise `False`. Examples: .. code-block:: python >>> import paddle >>> support_ipu = paddle.is_compiled_with_ipu() )rrr/r/r/r0rrr _IPUPlacecCr2)a Return a Graphcore IPU Place Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> paddle.device.set_device('ipu') >>> place = paddle.device.IPUPlace() )rrr/r/r/r0rsrcCr2)a Whether paddle was built with WITH_XPU=ON to support Baidu Kunlun Returns (bool): whether paddle was built with WITH_XPU=ON Examples: .. code-block:: python >>> import paddle >>> support_xpu = paddle.device.is_compiled_with_xpu() )rrr/r/r/r0rr3rdev_idint _XPUPlacecCr.)a< Return a Baidu Kunlun Place Args: dev_id(int): Baidu Kunlun device id Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:XPU) >>> import paddle >>> paddle.device.set_device('xpu') >>> place = paddle.device.XPUPlace(0) )rr)r5r/r/r0rr1r int | NonecCs8tsdStdurtt}|atdkrdS|StS)a This function return the version of cudnn. the return value is int which represents the cudnn version. For example, if it return 7600, it represents the version of cudnn is 7.6. Returns: int: A int value which represents the cudnn version. If cudnn version is not installed, it return None. Examples: .. code-block:: python >>> import paddle >>> cudnn_version = paddle.device.get_cudnn_version() Nr)rr _cudnn_versionr6 cudnn_version)r:r/r/r0rs rdevicerc CsHt|ts|S|}|dr|dd}|tvr7td|dd d}t |d}t ||}|S|dkrAt }|S|dksI|d kr\t sQtd ttjj}|S|d kr~tshtd td d d}t |d}t|}|S|dkrtstdt}|Std|ptd|}td|}|rt std|d| dd}|d}t |}t|}|rtstd|d| dd}|d}t |}t|}|s"|s"| dd}|d} | tvr |d}t |}t | |}|Stdddddd d dgtD|S)Nr gpuZFLAGS_selected_s0,rcpuZdcuzLThe device should not be 'gpu', since PaddlePaddle is not compiled with CUDArzKThe device should not be 'xpu', since PaddlePaddle is not compiled with XPUZFLAGS_selected_xpusZipuzKThe device should not be 'ipu', since PaddlePaddle is not compiled with IPUzgpu:\d+zdcu:\d+zxpu:\d+zThe device should not be z., since PaddlePaddle is not compiled with CUDA:r z-, since PaddlePaddle is not compiled with XPUz3The device must be a string which is like 'cpu', {}z, css"|] }d|d|dVqdS)'z', 'z:x'Nr/).0xr/r/r0 %s  z$_convert_to_place..Znpu) isinstancer+lower startswithreplacerrosgetenvsplitr6rCPUPlacer ValueErrorrpaddle distributedZ ParallelEnvr5rrrrrematchformatjoin) r;Z lower_deviceZselected_devices device_idplaceZ selected_xpusZavailable_gpu_deviceZavailable_xpu_deviceZdevice_info_listr*r/r/r0_convert_to_places      IG@  70           rWcCst|}t||S)a] Paddle supports running calculations on various types of devices, including CPU, GPU, XPU, NPU and IPU. They are represented by string identifiers. This function can specify the global device which the OP will run. Args: device(str): This parameter determines the specific running device. It can be ``cpu``, ``gpu``, ``xpu``, ``npu``, ``gpu:x``, ``xpu:x``, ``npu:x`` and ``ipu``, where ``x`` is the index of the GPUs, XPUs or NPUs. Returns: Place,the Place to set. Examples: .. code-block:: python >>> import paddle >>> paddle.device.set_device("cpu") >>> x1 = paddle.ones(name='x1', shape=[1, 2], dtype='int32') >>> x2 = paddle.zeros(name='x2', shape=[1, 2], dtype='int32') >>> data = paddle.stack([x1,x2], axis=1) )rWr_set_expected_placer;rVr/r/r0r4s rcCsd}t}t|tjrd}|St|tjr"|}dt|}|St|tjr4|}dt|}|St|tj rHt }d|dd}|St|tj r`|}| }|dt|}|St d |d ) a This function can get the current global device of the program is running. It's a string which is like 'cpu', 'gpu:x', 'xpu:x' and 'npu:x'. if the global device is not set, it will return a string which is 'gpu:x' when cuda is available or it will return a string which is 'cpu' when cuda is not available. Examples: .. code-block:: python >>> import paddle >>> device = paddle.device.get_device() r@gpu:zxpu:zipus:{0-r }rAzThe device specification z is invalid)r_current_expected_place_rFrrMr get_device_idr+rrZget_ipu_device_countrget_device_typerN)r;rVrUZ num_devicesr*r/r/r0rTs.       rdev_type str | NonecCs|dur:trttdrt}|Sd}|Sttdr6t}|r2ttdr.t|dnd}|Sd}|Std|dkrStrOttdrKtnd}|Stdttd rmt|rmttdrit|}|Sd}|Std |) a" Return the number of devices available. Args: dev_type (str, optional): Device type string, e.g., 'gpu', 'npu', etc. If None, will return the number of CUDA devices if available, otherwise the first available custom device count. Returns: int: the number of devices available. Examples: .. code-block:: python >>> import paddle >>> paddle.device.device_count() >>> paddle.device.device_count('gpu') >>> paddle.device.device_count('npu') Nget_cuda_device_countrrget_custom_device_countz1Paddle is not compiled with GPU or Custom Device.r<z Paddle is not compiled with GPU.rz(Unsupported or unavailable device type: ) rOr hasattrrrbrrcrNr)r`numZ custom_typesr/r/r0 device_count{sZ      rf list[str]cCr2)aM Get all available device types. Returns: A list of all available device types. Examples: .. code-block:: python >>> import paddle >>> paddle.device.get_all_device_type() >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registered. >>> # Output: ['cpu'] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: ['cpu', 'gpu'] >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered. >>> # Output: ['cpu', 'CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['cpu', 'gpu', 'CustomCPU', 'CustomGPU'] )rrr/r/r/r0rrlist[str] | NonecCr2)a- Get all available custom device types. Returns: A list of all available custom device types. Examples: .. code-block:: python >>> import paddle >>> paddle.device.get_all_custom_device_type() >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: None >>> # Case 2: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['CustomCPU', 'CustomGPU'] )rrr/r/r/r0rrcCr2)ak Get all available devices. Returns: A list of all available devices. Examples: .. code-block:: python >>> import paddle >>> paddle.device.get_available_device() >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registered. >>> # Output: ['cpu'] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: ['cpu', 'gpu:0', 'gpu:1'] >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered. >>> # Output: ['cpu', 'CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['cpu', 'gpu:0', 'gpu:1', 'CustomCPU', 'CustomGPU:0', 'CustomGPU:1'] )rr r/r/r/r0r rhr cCr2)a4 Get all available custom devices. Returns: A list of all available custom devices. Examples: .. code-block:: python >>> import paddle >>> paddle.device.get_available_custom_device() >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: None >>> # Case 2: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['CustomCPU', 'CustomGPU:0', 'CustomGPU:1'] )rr!r/r/r/r0r!rjr!_CustomPlaceLike | NonercCsd}|dur@t|tr8|d}|dkr|}d}n/|d|}||dd}|s3td|dt|}ntd|d td|d |d krStjj |St |s`td |d t ||S) a? Return the properties of given device. Args: device(|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like npu:x' which to get the properties of the device from. If device is None, the device is the current device. Default: None. Returns: _customDeviceProperties: The properties of the device which include ASCII string identifying device, major compute capability, minor compute capability, global memory available and the number of multiprocessors on the device. Examples: .. code-block:: python >>> # import paddle >>> # paddle.device.set_device('npu') >>> # paddle.device.get_device_properties('npu:0') >>> # _customDeviceProperties(name='', major=0, minor=0, total_memory=0MB, multi_processor_count=0) >>> # paddle.device.get_device_properties('npu') >>> # _customDeviceProperties(name='', major=0, minor=0, total_memory=0MB, multi_processor_count=0) NrArr zInvalid device ID 'z:'. After colon must be digits only. Example: 'metax_gpu:0'z The input: z is not expected. Because paddle.device.get_device_properties only support str. Please input appropriate device again!Example: 'metax_gpu:0'r<z/PaddlePaddle is not compiled with support for 'zT' device. Please reinstall PaddlePaddle with Custom Device support to call this API.) rFr+rfindisdigitrNr6rOr;r r"rr)r;Z device_nameZ colon_idxrU device_id_strr/r/r0r"'s6          r"op_namec Cs|durtSt|tr[|}trd}nd}t}t|dkr8|dkr+|d}n!td|d|dd|D]}|d\}}t||krK|}q:|durZtd|d |nVt|tj rhd}| }nIt|tj rw| }| }n:t|t r|d rt|d d}n'd|vr|dd\}}t|}ntd |d |dtd|d |d|dksJd|dtr|tksJd|dt|S|t|ksJd|d|dt||S)a Return the id of the given device. It is just a utility that will not be exposed to users. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str): The device, the id of the device or the string name of device like 'gpu:x' or 'custom_device:x'. Default: None. Return: int: The id of the given device. If device is None, return the id of current device. Nr<r rz Device id z) not found in available_custom_devices: [z:0]rAz( not found in available_custom_devices: r[zThe current string z is not expected. Because zi only support string which is like 'gpu:x' or ':x'. Please input appropriate string again!zThe device type z only support int, str (format 'gpu:x' or ':x'), paddle.CUDAPlace or paddle.CustomPlace. Please input appropriate device again!z4The device id must be not less than 0, but got id = .zThe device id z exceeds gpu card number z exceeds z device card number )rZget_cuda_current_device_idrFr6r r!lenrNrLrr^rr_r+rHrfrc) r;rprUr*Zavailable_custom_devicesdr`r5ror/r/r0extract_device_idusl               ruNonecCs@tj}trtdSt|drtdStd)a Releases idle cached memory held by the allocator so that those can be used in other GPU application and visible in `nvidia-smi`. In most cases you don't need to use this function, Paddle does not release the memory back to the OS when you remove Tensors on the GPU, Because it keeps gpu memory in a pool so that next allocations can be done much faster. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> tensor = paddle.randn([512, 512, 512], "float64") >>> del tensor >>> paddle.device.empty_cache() rzThe API paddle.device.empty_cache is not supported in CPU-only PaddlePaddle. Please reinstall PaddlePaddle with GPU or custom device support to call this API.N) rOr;rrr Zcuda_empty_cacherZdevice_empty_cacherN)custom_devicesr/r/r0 empty_caches   rxcCPd}tj}ts|rt|dstd|dt||d}td|S)a Return the peak size of memory that is allocated to tensor of the given device. This Note: The size of memory allocated to tensor is 256-byte aligned in Paddle, which may larger than the memory size that tensor actually need. For instance, a float32 0-D Tensor with shape [] will take up 256 bytes memory, even though storing a float32 data requires only 4 bytes. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Return: int: The peak size of memory that is allocated to tensor of the given device, in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> max_memory_allocated_size = paddle.device.max_memory_allocated(paddle.CUDAPlace(0)) >>> max_memory_allocated_size = paddle.device.max_memory_allocated(0) >>> max_memory_allocated_size = paddle.device.max_memory_allocated("gpu:0") z"paddle.device.max_memory_allocatedrThe API } is not supported in CPU-only PaddlePaddle. Please reinstall PaddlePaddle with GPU or custom device support to call this API.rp Allocated rOr;rrr rrNruZdevice_memory_stat_peak_valuer;namerwrUr/r/r0max_memory_allocated     rcCry)a Return the peak size of memory that is held by the allocator of the given device. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Return: int: The peak size of memory that is held by the allocator of the given device, in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> max_memory_reserved_size = paddle.device.max_memory_reserved(paddle.CUDAPlace(0)) >>> max_memory_reserved_size = paddle.device.max_memory_reserved(0) >>> max_memory_reserved_size = paddle.device.max_memory_reserved("gpu:0") z!paddle.device.max_memory_reservedrrzr{r|Reservedr~rr/r/r0max_memory_reserved      rcCTd}tj}ts|rt|dstd|dt||d}td|dS)a Reset the peak size of memory that is allocated to tensor of the given device. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> paddle.device.reset_max_memory_allocated(paddle.CUDAPlace(0)) >>> paddle.device.reset_max_memory_allocated(0) >>> paddle.device.reset_max_memory_allocated("gpu:0") z(paddle.device.reset_max_memory_allocatedrrzr{r|r}N rOr;rrr rrNruZ#device_memory_stat_reset_peak_valuerr/r/r0reset_max_memory_allocated2    rcCr)a Reset the peak size of memory that is held by the allocator of the given device. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> paddle.device.reset_max_memory_reserved(paddle.CUDAPlace(0)) >>> paddle.device.reset_max_memory_reserved(0) >>> paddle.device.reset_max_memory_reserved("gpu:0") z'paddle.device.reset_max_memory_reservedrrzr{r|rNrrr/r/r0reset_max_memory_reservedWrrcCry)a Return the current size of memory that is allocated to tensor of the given device. Note: The size of memory allocated to tensor is 256-byte aligned in Paddle, which may be larger than the memory size that tensor actually need. For instance, a float32 0-D Tensor with shape [] will take up 256 bytes memory, even though storing a float32 data requires only 4 bytes. Args: device(paddle.CUDAPlace|paddle.CustomPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Return: int: The current size of memory that is allocated to tensor of the given device, in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> memory_allocated_size = paddle.device.memory_allocated(paddle.CUDAPlace(0)) >>> memory_allocated_size = paddle.device.memory_allocated(0) >>> memory_allocated_size = paddle.device.memory_allocated("gpu:0") zpaddle.device.memory_allocatedrrzr{r|r} rOr;rrr rrNruZ device_memory_stat_current_valuerr/r/r0memory_allocated|rrcCry)ap Return the current size of memory that is held by the allocator of the given device. Args: device(paddle.CUDAPlace|int|str|None, optional): The device, the id of the device or the string name of device like 'gpu:x'. If device is None, the device is the current device. Default: None. Return: int: The current size of memory that is held by the allocator of the given device, in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> memory_reserved_size = paddle.device.memory_reserved(paddle.CUDAPlace(0)) >>> memory_reserved_size = paddle.device.memory_reserved(0) >>> memory_reserved_size = paddle.device.memory_reserved("gpu:0") zpaddle.device.memory_reservedrrzr{r|rrrr/r/r0memory_reservedrrc@sreZdZUdZded<ded<ded<  dd ddZd!d"ddZd#ddZd$ddZd%ddZ d&ddZ dS)'r$a A device event wrapper around StreamBase. Args: device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)|None): Which device the stream run on. If device is None, the device is the current device. Default: None. It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice, where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n). enable_timing (bool, optional): indicates if the event should measure time, default is False blocking (bool, optional): if True, ``wait`` will be blocking, default is False interprocess (bool): if True, the event can be shared between processes, default is False Returns: Event: The event. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e1 = paddle.device.Event() >>> e2 = paddle.device.Event('custom_cpu') >>> e3 = paddle.device.Event('custom_cpu:0') >>> e4 = paddle.device.Event(paddle.CustomPlace('custom_cpu', 0)) PlaceLike | Noner;r- enable_timing_InitEventBase event_baseNFblocking interprocessr,rvcCs|dur tj|_nt|trtj||_n||_tr0t|jtjr0t ||||_ dSt rBt|jtj rBt |_ dSt|jtjr[t |j|j||||_ dStddtj)Ndevice should be gpu, xpu, {}r?)rOrr]r;rFr+rWr rr CUDAEventrrrXPUEventrCustomDeviceEventr_r^ TypeErrorrSrTr)selfr;rrrr/r/r0__init__s8    zEvent.__init__stream Stream | NonecCs$|dur t|j}|j|jdS)a\ Records the event in a given stream. Args: stream(Stream, optional): The given stream. By default, stream is None, event will be recorded in current_stream. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e = paddle.device.Event() >>> e.record() >>> s = paddle.device.Stream() >>> e.record(s) N)r%r;rrecord stream_baserrr/r/r0rs z Event.recordcC |jS)a Checks if all work currently captured by event has completed. Returns: bool: Whether all work currently captured by event has completed. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e = paddle.device.Event() >>> e.record() >>> e.query() )rqueryrr/r/r0r7s z Event.query end_eventr6cCs|j|jS)aF Returns the time elapsed in milliseconds after the event was recorded and before the end_event was recorded. Returns: int: The time. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e1 = paddle.device.Event() >>> e1.record() >>> e2 = paddle.device.Event() >>> e2.record() >>> e1.elapsed_time(e2) )r elapsed_time)rrr/r/r0rMszEvent.elapsed_timecC|jdS)a4 Waits for the event to complete. Waits until the completion of all work currently captured in this event. This prevents the CPU thread from proceeding until the event completes. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e = paddle.device.Event() >>> e.record() >>> e.synchronize() N)rr)rr/r/r0r)gszEvent.synchronize'core.CUDAEvent | core.CustomDeviceEventcCs|jSN)rrr/r/r0__repr__szEvent.__repr__)NFFF) r;rrr-rr-rr-r,rvrrrr,rvr,r-)rr$r,r6r,rv)r,r) __name__ __module__ __qualname____doc____annotations__rrrrr)rr/r/r/r0r$s  (   r$cseZdZUdZded<ded<   d*d+ddZd,ddZd-ddZd.d/ddZd0ddZ d1ddZ e dd Z d2fd#d$ Z d3d%d&Zd4d(d)ZZS)5r#aa A device stream wrapper around StreamBase. Args: device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)|None): Which device the stream run on. If device is None, the device is the current device. Default: None. It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice, where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n). priority(int, optional): priority of the CUDA stream. Can be either 1 (high priority) or 2 (low priority). By default, streams have priority 2. Returns: Stream: The stream. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s1 = paddle.device.Stream() >>> s2 = paddle.device.Stream('custom_cpu') >>> s3 = paddle.device.Stream('custom_cpu:0') >>> s4 = paddle.device.Stream(paddle.CustomPlace('custom_cpu', 0)) _InitStreamBaserrr;Nrpriorityr6_InitStreamBase | Noner,rvcCs|durt|tjtjtjfr||_|j|_dStd|dur't j |_nt|t r4t j ||_n||_t rNt|jt jrNt|j||_dSt rdt|jt jrdt|j|_dSt|jt jr}tj|j|j|dd|_dStddt j)Nz?stream_base should be CUDAStream, XPUStream, CustomDeviceStreamF)rrr?)rFr CUDAStreamCustomDeviceStream XPUStreamrrVr;rrOrr]r+rWr rr^rrrr_rSrTr)rr;rrr/r/r0rsL     zStream.__init__eventr$cCs|j|jdS)aV Makes all future work submitted to the stream wait for an event. Args: event (Event): an event to wait for. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s1 = paddle.device.Stream() >>> s2 = paddle.device.Stream() >>> e = paddle.device.Event() >>> e.record(s1) >>> s2.wait_event(e) N)r wait_eventrrrr/r/r0rzStream.wait_eventrcCs|j|jdS)a~ Synchronizes with another stream. All future work submitted to this stream will wait until all kernels submitted to a given stream at the time of call complete. Args: stream (Stream): a stream to synchronize. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s1 = paddle.device.Stream() >>> s2 = paddle.device.Stream() >>> s1.wait_stream(s2) N)r wait_streamrr/r/r0rrzStream.wait_stream Event | NonecCs |dur t|j}|||S)aP Records an event. Args: event (Event, optional): event to record. If not given, a new one will be allocated. Returns: Event: Recorded event. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s = paddle.device.Stream() >>> e1 = s.record_event() >>> e2 = paddle.device.Event() >>> s.record_event(e2) N)r$r;rrr/r/r0 record_event s  zStream.record_eventr-cCr)a Checks if all the work submitted has been completed. Returns: bool: Whether all kernels in this stream are completed. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s = paddle.device.Stream() >>> s.query() )rrrr/r/r0r+s z Stream.querycCr)a Wait for all the kernels in this stream to complete. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s = paddle.device.Stream() >>> s.synchronize() N)rr)rr/r/r0r)@szStream.synchronizecCsFt|jtjrt|jjSt|jtjrt|jjSt|jj Sr) rFrrrctypesZc_void_pZ cuda_streamrZ xpu_streamZ raw_streamrr/r/r0_as_parameter_Us zStream._as_parameter_orcst|tr t|SdS)NF)rFr#super__eq__)rr __class__r/r0r^s  z Stream.__eq__cCst|j|jfSr)hashrr;rr/r/r0__hash__cszStream.__hash__r+cCsd|jd|jjddS)Nz)r;rvaluerr/r/r0rfszStream.__repr__)NrN)r;rrr6rrr,rv)rr$r,rv)rr#r,rvr)rrr,r$rr)rrr,r-)r,r6r,r+)rrrrrrrrrrr)propertyrrrr __classcell__r/r/rr0r#s$  2      r#rcCs|dur tj}nt|trtj|}n|}tr,t|tjr,t t | dSt r@t|tjr@t t | dSt|tjrSt t || dStddtj)a Return the current stream by the device. Args: device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): The device which want to get stream from. If device is None, the device is the current device. Default: None. It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice, where ``x`` is the index of the GPUs, CustomDevices. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n). Returns: Stream: The stream to the device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s1 = paddle.device.current_stream() >>> s2 = paddle.device.current_stream("custom_cpu:0") >>> place = paddle.CustomPlace('custom_cpu', 0) >>> s3 = paddle.device.current_stream(place) N)rrr?)rOrr]rFr+r;rWr rr#rZ_get_current_streamr^rrZ_xpu_get_current_streamrZ!_get_current_custom_device_streamr_rrSrTrrYr/r/r0r%js0      r%rcCst|jj}trt|jjtjrt|j|St r/t|jjtj r/t |jj |St|jjtj rIt|jj|jj|j|Stddtj)a Set the current stream. Args: stream(Stream): The selected stream. Returns: Stream: The previous stream. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s = paddle.device.Stream() >>> paddle.device.set_stream(s) rr?)r%rrVrOr rFrrZ_set_current_streamrrZ_xpu_set_current_streamidxrZ!_set_current_custom_device_streamr_r^rrSrTr;r)rZ prev_streamr/r/r0r&s.        r&c@s:eZdZUdZded<ddddZdd d ZdddZdS)r'aE Notes: This API only supports dynamic graph mode currently. A context manager that specifies the current stream context by the given stream. Args: stream(Stream, optional): the selected stream. If stream is None, just yield. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> s = paddle.device.Stream() >>> data1 = paddle.ones(shape=[20]) >>> data2 = paddle.ones(shape=[20]) >>> data3 = data1 + data2 >>> with paddle.device.stream_guard(s): ... s.wait_stream(paddle.device.default_stream()) # type: ignore[attr-defined] ... data4 = data1 + data3 rrNr,rvcCs ||_dSr)rrr/r/r0rs zstream_guard.__init__cCsn|j}|dur dSt|j|_|jj|jkr1tjj|_tjj |jt|j|_ t |dSt |dSr) rr%r;src_prev_streamrObaserr] tmp_placerXdst_prev_streamr&)r cur_streamr/r/r0 __enter__s    zstream_guard.__enter__exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | NonecCsV|j}|dur dS|jj|jkr$t|jtjj|j t|jdSt|jdSr) rrr;r&rrOrrrXr)rrrrrr/r/r0__exit__s zstream_guard.__exit__rrrrrrrrrr,rvrrrrrrrrr/r/r/r0r's   r'c@s@eZdZUdZded<ded<dd d Zdd d ZdddZdS)r(aW Notes: This API only supports dynamic graph mode currently. A context manager that specifies the current device context by the given device. Args: device(PlaceLike): The specified device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # Set the global default device to CPU >>> paddle.set_device("cpu") >>> # Temporarily switch to GPU:0 using device_guard with string input >>> with paddle.device.device_guard("gpu:0"): ... x = paddle.randn([4, 4]) # Create a Tensor on GPU:0 ... x = x.tanh() * 2 # Perform computation on GPU:0 ... print(x.place) # Check the device of the Tensor Place(gpu:0) >>> # Set the global default device to GPU:0 >>> paddle.set_device("gpu:0") >>> # Temporarily switch to CPU using device_guard with Place object (CPUPlace) >>> cpu_place = paddle.CPUPlace() >>> with paddle.device.device_guard(cpu_place): ... x = paddle.randn([4, 4]) # Create a Tensor on CPU ... x = x.tanh() * 2 # Perform computation on CPU ... print(x.place) Place(cpu) r _target_place_original_placer;rr,rvcCsHt|trtj||_dSt|tjjjr||_dSt dt |)Nz_'device' must be a string or an instance of a subclass of paddle.base.libpaddle.Place, but got ) rFr+rOr;rWrrZ libpaddlerrNtype)rr;r/r/r0r=s  zdevice_guard.__init__cCs.tj|_|j|jkrtj|jdSdSr)rOrr]rrrXrr/r/r0rHs  zdevice_guard.__enter__rrrrrrcCs"|j|jkrtj|jdSdSr)rrrOrrX)rrrrr/r/r0rMs zdevice_guard.__exit__N)r;rr,rvrrrr/r/r/r0r(s $  r(cCs|dur tj}nt|trtj|}n|}tr+t|tjr+t | dSt r>t|tj r>t | dSt|tjrPt || dStddtj)a Wait for the compute on the given device to finish. Args: device(str|paddle.CUDAPlace(n)|paddle.XPUPlace(n)|paddle.CustomPlace(n)): The device which want to wait for. If device is None, the device is the current device. Default: None. It can be ``gpu``, ``gpu:x``, ``xpu``, ``xpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice, where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.XPUPlace(n) or paddle.CustomPlace(n). Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> paddle.device.synchronize() >>> paddle.device.synchronize("custom_cpu:0") >>> place = paddle.CustomPlace('custom_cpu', 0) >>> paddle.device.synchronize(place) Nrr?)rOrr]rFr+r;rWr rrZ_device_synchronizer^rrZ_xpu_device_synchronizerZ_synchronize_custom_devicer_rrSrTrrYr/r/r0r)Ws$    r))r*r+r,r-r)r,r4)r5r6r,r7)r,r8)r;rr,r)r;r+r,rrr)r`rar,r6)r,rg)r,ri)r;rkr,r)r;rrpr+r,r6r)r;rkr,r6)r;rkr,rv)r;rr,r#)rr#r,r#)r;rr,rv)N __future__rrrJrQtypingrrZtyping_extensionsrrOZ paddle.baserrZpaddle.base.frameworkrr r r rZr rtypesrrr4rr7Zpaddle._typing.device_likerZpaddle.base.corerrrrrrrrrrrZpaddle.base.libpaddlerr+r6rr__all__r9rrrrrWrrrfrrr r!r"rurxrrrrrrr$r#r%r&r'r(r)r/r/r/r0s             ! X ' @    N N  + ' % % +'6 h 71CB