o "jy@sddlZddlZddlZddlZddlmZmZddlmZm Z m Z m Z ddl m Z mZgdZdaddZd d Zd d Zd dZddZddZddZddZddZddZddZddZdd ZGd!d"d"ZGd#d$d$Zd-d%d&Z d'd(Z!Gd)d*d*Z"d-d+d,Z#dS).N)core framework)is_compiled_with_cinnis_compiled_with_cudais_compiled_with_distributeis_compiled_with_rocm)cudaxpu)get_cudnn_version set_device get_deviceXPUPlaceIPUPlaceis_compiled_with_xpuis_compiled_with_ipurrrris_compiled_with_custom_deviceget_all_device_typeget_all_custom_device_typeget_available_deviceget_available_custom_deviceStreamEventcurrent_stream set_stream stream_guard synchronizecC 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) device_typerW/var/www/html/Deteccion_Ine/venv/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() )rrrrrr rSrcCr")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() )rrrrrr rdsrcCr")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() )rrrrrr rvr#rcCr)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)dev_idrrr rr!rcCs8tsdStdurtt}|atdkrdS|StS)a This function return the version of cudnn. the retuen 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_versionint cudnn_version)r'rrr r s r c Cs|}|tvr%td|ddd}t|d}t||}|S|dkr/t}|S|dkrFt s;t dt t j j}|S|d krhtsRt d td dd}t|d}t|}|S|d krztstt d t}|Std|}td|}|rt st d||dd}|d}t|}t |}|rtst d||dd}|d}t|}t|}|s|s|dd}|d} | tvr|d}t|}t| |}|St ddddgdtD|S)NZFLAGS_selected_s0,rcpugpuzLThe device should not be 'gpu', since PaddlePaddle is not compiled with CUDAr zKThe 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+zxpu:\d+zIThe device should not be {}, since PaddlePaddle is not compiled with CUDA:rzHThe device should not be {}, 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).0xrrr s  z$_convert_to_place..)r,r Znpu)lowerrrosgetenvsplitr& CustomPlaceCPUPlacer ValueError CUDAPlacepaddle distributedZ ParallelEnvr$rrrrrematchformatjoin) deviceZ lower_deviceZselected_devices device_idplaceZ selected_xpusZavaliable_gpu_deviceZavaliable_xpu_deviceZdevice_info_listrrrr _convert_to_places   B@9  0)           rCcCst|}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) )rCr_set_expected_placer@rBrrr r s r cCsd}t}t|tjrd}|St|tjr"|}dt|}|St|tjr4|}dt|}|St|tj rPt }d|dd}d|dd}|St|tj rh|}| }|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 avaliable or it will return a string which is 'cpu' when cuda is not avaliable. Examples: .. code-block:: python >>> import paddle >>> device = paddle.device.get_device() r+zgpu:zxpu:zipus:{0-r}r-zThe device specification z is invalid)rZ_current_expected_place_ isinstancerr7r9 get_device_idstrrrZget_ipu_device_countr6get_device_typer8)r@rBrAZ num_devicesrrrr r )s0       r cCr")aI 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 registerd. >>> # Output: ['cpu'] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registerd. >>> # Output: ['cpu', 'gpu'] >>> # Case 3: paddlepaddle-cpu package installed, and custom deivce 'CustomCPU' is registerd. >>> # Output: ['cpu', 'CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd. >>> # Output: ['cpu', 'gpu', 'CustomCPU', 'CustomGPU'] )rrrrrr rQrcCr")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 registerd. >>> # Output: None >>> # Case 2: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd. >>> # Output: ['CustomCPU', 'CustomGPU'] )rrrrrr rorcCr")ag 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 registerd. >>> # Output: ['cpu'] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registerd. >>> # Output: ['cpu', 'gpu:0', 'gpu:1'] >>> # Case 3: paddlepaddle-cpu package installed, and custom deivce 'CustomCPU' is registerd. >>> # Output: ['cpu', 'CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd. >>> # Output: ['cpu', 'gpu:0', 'gpu:1', 'CustomCPU', 'CustomGPU:0', 'CustomGPU:1'] )rrrrrr rrLrcCr")a2 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 registerd. >>> # Output: None >>> # Case 2: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd. >>> # Output: ['CustomCPU', 'CustomGPU:0', 'CustomGPU:1'] )rrrrrr rrMrc@sLeZdZdZ    dddZdddZdd Zd d Zd d ZddZ dS)ra A device event wrapper around StreamBase. Args: device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream runn 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 CustomDevicec, 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)) NFcCs|dur tj|_nt|trtj||_n||_tr0t|jtjr0t ||||_ dSt|jtj rIt |j|j||||_ dStddtj)Ndevice should be gpu, xpu, {}r*)r:r_current_expected_placer@rHrJrCrr9rZ CUDAEvent event_baser6ZCustomDeviceEventrKrI TypeErrorr>r?r)selfr@Z enable_timingblockingZ interprocessrrr __init__s0    zEvent.__init__cCs$|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)rr@rPrecord stream_baserRstreamrrr rUs 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() )rPqueryrRrrr rZs z Event.querycCsdS)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) rr)rRZ end_eventrrr elapsed_time3szEvent.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)rPrr[rrr rMszEvent.synchronizecCs|jSN)rPr[rrr __repr__eszEvent.__repr__)NFFFr^) __name__ __module__ __qualname____doc__rTrUrZr\rr_rrrr rs # rcspeZdZdZdddZddZdd Zdd d Zd d ZddZ e ddZ fddZ ddZ ddZZS)ra^ A device stream wrapper around StreamBase. Args: device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream runn 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 CustomDevicec, 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)) NcCs|durt|tjtjfr||_|j|_dStd|dur%tj |_nt|t r2tj ||_n||_t rLt|jtjrLt|j||_dSt|jtjretj|j|j|dd|_dStddtj)Nz4stream_base should be CUDAStream, CustomDeviceStreamF)rSrNr*)rHr CUDAStreamZCustomDeviceStreamrVrBr@rQr:rrOrJrCrr9rIr6rKr>r?r)rRr@priorityrVrrr rTsB      zStream.__init__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)rV wait_eventrPrReventrrr rgzStream.wait_eventcCs|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)rV wait_streamrWrrr rkrjzStream.wait_streamcCs |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)rr@rUrhrrr record_events  zStream.record_eventcCrY)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() )rVrZr[rrr rZs 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)rVrr[rrr rszStream.synchronizecCs*t|jtjrt|jjSt|jjSr^)rHrVrrectypesc_void_pZ cuda_streamZ raw_streamr[rrr _as_parameter_.szStream._as_parameter_cst|tr t|SdS)NF)rHrsuper__eq__)rRo __class__rr rq5s  z Stream.__eq__cCst|j|jfSr^)hashrVr@r[rrr __hash__:szStream.__hash__cCsd|j|jjS)Nz-)r>r@rovaluer[rrr r_=s zStream.__repr__)NrdNr^)r`rarbrcrTrgrkrlrZrpropertyrorqrvr_ __classcell__rrrsr ris (   rcCs|dur tj}nt|trtj|}n|}tr,t|tjr,t t | dSt|tj r?t 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 CustomDevicec, where ``x`` is the index of the GPUs, CustomDevicecs. 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)rVrNr*)r:rrOrHrJr@rCrr9rrZ_get_current_streamrIr6Z!_get_current_custom_device_streamrKrQr>r?rrErrr rCs(     rcCst|jj}trt|jjtjrt|j|St|jjtj r4t |jj |jj |j|St ddtj)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) rNr*)rrVrBr:rrHr9rZ_set_current_streamr6Z!_set_current_custom_device_streamrKrIrQr>r?r@r)rXZ prev_streamrrr rvs$       rc@s*eZdZdZd ddZddZddZdS) ra( 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()) ... data4 = data1 + data3 NcCs ||_dSr^)rXrWrrr rTs zstream_guard.__init__cCsn|j}|dur dSt|j|_|jj|jkr1tjj|_tjj |jt|j|_ t |dSt |dSr^) rXrr@src_prev_streamr:baserrO tmp_placerDdst_prev_streamr)rR cur_streamrrr __enter__s    zstream_guard.__enter__cGsV|j}|dur dS|jj|jkr$t|jtjj|j t|jdSt|jdSr^) rXrzr@rr}r:r{rrDr|)rRargsr~rrr __exit__s zstream_guard.__exit__r^)r`rarbrcrTrrrrrr rs   rcCs|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 CustomDevicec, 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) NrNr*)r:rrOrHrJr@rCrr9rZ_device_synchronizerIrrZ_xpu_device_synchronizer6Z_synchronize_custom_devicerKrQr>r?rrErrr rs$    rr^)$rmr3r<r:Z paddle.baserrZpaddle.base.frameworkrrrrrFr r __all__r%rrrrrr rCr r rrrrrrrrrrrrrr s<!L (- [3-<