Αi0urSSKJr SSKJrJr SSKrSSKJrJrJr J r SSK J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r( \(a\\RRR\*\+S4r,S$SjrS%S&Sjjr-S%S'S jjr.S$S jrS%S(S jjr/S%S)S jjr0S%S*S jjr1S+SjrS%S,Sjjr2S%S-Sjjr3"SS5r4Sr5"SS\65r7S.Sjr8S%S*Sjjr9S/Sjr:S0Sjr;S$SjrS%S1Sjjr?S%S2Sjjr@S%S2SjjrAS%S1S jjrBS&S!jrCS%S3S"jjrD/S#QrEg)4) annotations) TYPE_CHECKINGUnionN)basecoredevice framework)EventStream StreamContext_device_to_paddleampcurrent_devicer ipc_collect is_availableis_bf16_supportedis_current_stream_capturing manual_seedmanual_seed_allreset_peak_memory_stats set_streamstream) BFloat16Tensor BoolTensor ByteTensor CharTensor DoubleTensor FloatTensor HalfTensor IntTensor LongTensor ShortTensorc[5$)a Check whether **any supported device** is available in the current environment. This function checks whether Paddle is built with support for at least one type of accelerator (e.g., CUDA, XPU, CustomDevice) and whether there is at least one device of that type available. If any supported device is available, this function returns True. Otherwise, it returns False. Returns: bool: True if there is at least one available device (GPU/XPU/CustomDevice), False otherwise. Examples: .. code-block:: python >>> import paddle >>> if paddle.cuda.is_available(): ... print("At least one device is available") ... else: ... print("No supported devices available") )_device_is_availableT/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/cuda/__init__.pyrr:s 2 !!r&cF[U5n[R"U5 g)aT Wait for all streams on a given device to complete. This function blocks the calling thread until all the operations on the specified device have finished. It is useful for ensuring synchronization between CPU and GPU or across multiple devices. Args: device (CUDAPlace | CustomPlace | int | str | None, optional): The target device to synchronize. - None: Synchronize the current device. - int: Device index, e.g., ``2`` means ``gpu:2``. - str: Device string, e.g., ``'cuda:0'`` or ``'gpu:0'``. - CUDAPlace: A Paddle CUDA place object. - CustomPlace: A Paddle custom device place object. Returns: None Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle # synchronize the current device >>> paddle.cuda.synchronize() N)r paddle_device synchronizerdevs r'r*r*Vs8 F #Cc"r&cD[U5n[R"U5$)aI Return the current stream for the given device. Args: device (int | str | paddle.CUDAPlace | paddle.CustomPlace | None, optional): The target device to query. - None: use the current device. - int: device index (e.g., 0 -> 'gpu:0'). - str: device string (e.g., "cuda:0", "gpu:1"). - CUDAPlace or CustomPlace: Paddle device objects. Returns: core.CUDAStream: The current CUDA stream associated with the given device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle # Get the current stream on the default CUDA device >>> s1 = paddle.cuda.current_stream() >>> print(s1) # Get the current stream on device cuda:0 >>> s2 = paddle.cuda.current_stream("cuda:0") >>> print(s2) )r r)current_streamr+s r'r.r.vs< F #C  ' ' ,,r&c[5$)a Check whether the current stream is in CUDA graph capturing state. Returns: bool: True if the current stream is capturing, False otherwise. Examples: .. code-block:: python >>> import paddle >>> if paddle.device.is_available(): ... graph = paddle.device.cuda.graphs.CUDAGraph() ... graph.capture_begin() ... print(paddle.cuda.is_current_stream_capturing()) # True ... graph.capture_end() )_is_current_stream_capturingr%r&r'rrs " ( ))r&c.[R"U5$)a Get the properties of a CUDA device. Args: device (int | str | paddle.CUDAPlace | paddle.CustomPlace | None, optional): The target device to query. - None: use the current device. - int: device index (e.g., 0 -> 'gpu:0'). - str: device string (e.g., "cuda:0", "gpu:1"). - CUDAPlace or CustomPlace: Paddle device objects. Returns: DeviceProperties: An object containing the device properties, such as name, total memory, compute capability, and multiprocessor count. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle # Get the properties of the current device >>> props = paddle.cuda.get_device_properties() >>> print(props) )r)get_device_propertiesrs r'r2r2s8  . .v 66r&c.[R"U5$)a Get the name of a device. Args: device (int | str | paddle.CUDAPlace | paddle.CustomPlace | None, optional): The target device to query. - None: use the current device. - int: device index (e.g., 0 -> 'gpu:0'). - str: device string (e.g., "cuda:0", "gpu:1"). - CUDAPlace or CustomPlace: Paddle device objects. Returns: str: The name of the CUDA device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle # Get the name of the current CUDA device >>> name = paddle.cuda.get_device_name() >>> print(name) # Get the name of device cuda:0 >>> name0 = paddle.cuda.get_device_name("cuda:0") >>> print(name0) )r)get_device_namer3s r'r5r5s<  ( ( 00r&c.[R"U5$)a Get the compute capability (major, minor) of a device. Args: device (int | str | paddle.CUDAPlace | paddle.CustomPlace | None, optional): The target device to query. - None: use the current device. - int: device index (e.g., 0 -> 'gpu:0'). - str: device string (e.g., "cuda:0", "gpu:1"). - CUDAPlace or CustomPlace: Paddle device objects. Returns: tuple[int, int]: A tuple ``(major, minor)`` representing the compute capability of the CUDA device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle # Get compute capability of the current CUDA device >>> capability = paddle.cuda.get_device_capability() >>> print(capability) # e.g., (8, 0) # Get compute capability of device cuda:0 >>> capability0 = paddle.cuda.get_device_capability("cuda:0") >>> print(capability0) )r)get_device_capabilityr3s r'r7r7s<  . .v 66r&c[U5 g)a  Sets the seed for global default generator, which manages the random number generation. Args: seed(int): The random seed to set. Returns: None Examples: .. code-block:: python >>> import paddle >>> paddle.cuda.manual_seed_all(102) N)device_manual_seed_all)seeds r'rr s $4 r&c.[R"U5$)a Return the random number generator state of the specified device. Args: device (DeviceLike, optional): The device to retrieve the RNG state from. If not specified, uses the current default device (as returned by paddle.framework._current_expected_place_()). Can be a device object, integer device ID, or device string. Returns: core.GeneratorState: The current RNG state of the specified device. Examples: .. code-block:: python >>> import paddle >>> paddle.cuda.get_rng_state() )r) get_rng_stater3s r'r<r<"s&  & &v ..r&c0[R"X5 g)a" Set the random number generator state of the specified device. Args: new_state (core.GeneratorState): The desired RNG state to set. This should be a state object previously obtained from ``get_rng_state()``. device (DeviceLike, optional): The device to set the RNG state for. If not specified, uses the current default device (as returned by ``paddle.framework._current_expected_place_()``). Can be a device object, integer device ID, or device string. Returns: None Examples: .. code-block:: python >>> import paddle >>> # Save RNG state >>> state = paddle.cuda.get_rng_state() >>> # Do some random operations >>> x = paddle.randn([2, 3]) >>> # Restore RNG state >>> paddle.cuda.set_rng_state(state) N)r) set_rng_state) new_staters r'r>r>8s6 2r&c<\rSrSrSr\SSj5r\S5rSrg)nvtxiVz%Namespace for NVTX marker operations.cV[RRRU5 g)ag Push an NVTX range marker with the given message. Args: msg (str): The name of the NVTX range. Example: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # paddle.device.nvtx.range_push("test") is equivalent to paddle.cuda.nvtx.range_push("test") >>> paddle.cuda.nvtx.range_push("test") N)paddlerrnvprof_nvtx_push)msgs r' range_pushnvtx.range_pushYs  ))#.r&cT[RRR5 g)a  Pop the most recent NVTX range marker. Example: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # paddle.device.nvtx.range_pop("test") is equivalent to paddle.cuda.nvtx.range_pop("test") >>> paddle.cuda.nvtx.range_pop() N)rCrrnvprof_nvtx_popr%r&r' range_popnvtx.range_popjs  ((*r&r%N)rEstr) __name__ __module__ __qualname____firstlineno____doc__ staticmethodrFrJ__static_attributes__r%r&r'rArAVs+///  + +r&rAc6[RR$)aRetrieves the CUDA runtime API module. This function initializes the CUDA runtime environment if it is not already initialized and returns the CUDA runtime API module (_cudart). The CUDA runtime API module provides access to various CUDA runtime functions. Args: ``None`` Returns: module: The CUDA runtime API module (_cudart). Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> from paddle.cuda import cudart, check_error >>> import os >>> >>> os.environ['CUDA_PROFILE'] = '1' >>> >>> def perform_cuda_operations_with_streams(): >>> stream = paddle.cuda.Stream() >>> with paddle.cuda.stream(stream): >>> x = paddle.randn((100, 100), device='cuda') >>> y = paddle.randn((100, 100), device='cuda') >>> z = paddle.mul(x, y) >>> return z >>> >>> paddle.cuda.synchronize() >>> # print("====== Start nsys profiling ======") >>> check_error(cudart().cudaProfilerStart()) >>> paddle.core.nvprof_start() >>> paddle.core.nvprof_nvtx_push("Test") >>> result = perform_cuda_operations_with_streams() >>> paddle.core.nvprof_nvtx_pop() >>> # print("CUDA operations completed.") >>> check_error(paddle.cuda.cudart().cudaProfilerStop()) >>> # print("====== End nsys profiling ======") )r libpaddle_cudartr%r&r'cudartrWxsT >> ! !!r&c,^\rSrSrSU4SjjrSrU=r$) CudaErroric>[RRR[RRR U55n[ TU]USUS35 g)Nz ())rrUrVcudaGetErrorString cudaErrorsuper__init__)selfcoderE __class__s r'r_CudaError.__init__sQnn$$77 NN " " , ,T 2  C54&*+r&r%)raintreturnNone)rMrNrOrPr_rS __classcell__)rbs@r'rYrYs ,,r&rYc~U[RRRR:wa [ U5eg)aCheck the return code of a CUDA runtime API call. This function validates whether the given result code from a CUDA runtime call indicates success. If the result code is not :data:`base.libpaddle._cudart.cudaError.success`, it raises a :class:`CudaError`. Args: res (int): The CUDA runtime return code. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> from paddle.cuda import check_error >>> check_error(0) # check for cuda success code # will not raise Error >>> # check_error(1) # check for cuda error code 1(invalid argument), will raise Error >>> # check_error(2) # check for cuda error code 2(out of memory), will raise Error N)rrUrVr]successrY)ress r' check_errorrks1( dnn$$..666n7r&c0Uc[R"5n[U[5(a[R"U5n[U[ 5(aUnO[U[ R5(a5[U[ R5(a$UR"5(d[SU35e[U[ R5(aUR"5OUR"5n[5RU5$)a,Return the free and total GPU memory (in bytes) for a given device using ``cudaMemGetInfo``. This function queries the CUDA runtime for the amount of memory currently available and the total memory capacity of the specified device. Args: device (DeviceLike, optional): The target device. If ``None`` (default), the current device, as returned by ``paddle.device.get_device`` will be used. Returns: tuple[int, int]: A tuple ``(free, total)``, where - ``free`` (int): The number of free bytes of GPU memory available. - ``total`` (int): The total number of bytes of GPU memory. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> from paddle.cuda import mem_get_info >>> free_bytes, total_bytes = mem_get_info() z!Expected a cuda device, but got: )r) get_device isinstancerL_convert_to_placerdr CUDAPlacePlace is_gpu_place ValueError get_device_id gpu_device_idrWcudaMemGetInfo)r device_ids r' mem_get_inforxs.~#..0&#*<>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> count = paddle.cuda.device_count() >>> print(f"Number of devices available: {count}") )r) device_countr%r&r'rzrzs"  % % ''r&c.[R"5 g)a7 Release all unoccupied cached memory currently held by the caching allocator so that those can be used in other application and visible in nvidia-smi. Returns: None Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # Create a tensor to allocate memory >>> tensor = paddle.randn([1000, 1000], device='cuda') >>> # Delete the tensor to free memory (but it may still be cached) >>> del tensor >>> # Release the cached memory >>> paddle.cuda.empty_cache() N)r) empty_cacher%r&r'r|r|s*r&c[R"5n[R"5nSn[R"5nU(a)UH"n[R "U5(dM Sn O OSnU=(d U=(d U$)al Return whether device has been initialized. Returns: bool: True if any device (CUDA, XPU, or Custom) has been initialized, False otherwise. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> initialized = paddle.cuda.is_initialized() >>> print(f"Device initialized: {initialized}") FT)ris_compiled_with_cudais_compiled_with_xpur)get_all_custom_device_typeis_compiled_with_custom_device)cuda_initializedxpu_initializedcustom_device_initializedcustom_device_types device_types r'is_initializedrsz"113//1O!&'BBD.K22;??,0)/ %*!  K K2KKr&c.[R"U5$)aL Return the current device memory occupied by tensors in bytes for a given device. Args: device (DeviceLike, optional): The device to query. If None, use the current device. Can be paddle.CUDAPlace, paddle.CustomPlace, paddle.XPUPlace, int (device index), or str (device string). Returns: int: The current memory occupied by tensors in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # Get memory allocated for current device >>> mem_allocated = paddle.cuda.memory_allocated() >>> print(f"Memory allocated: {mem_allocated} bytes") >>> >>> # Get memory allocated for specific device >>> mem_allocated = paddle.cuda.memory_allocated(0) >>> print(f"Memory allocated on device 0: {mem_allocated} bytes") )r)memory_allocatedr3s r'rrBs4  ) )& 11r&c.[R"U5$)a^ Return the peak 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 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|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.cuda.max_memory_allocated(paddle.CUDAPlace(0)) >>> max_memory_allocated_size = paddle.cuda.max_memory_allocated(0) >>> max_memory_allocated_size = paddle.cuda.max_memory_allocated("gpu:0") )r)max_memory_allocatedr3s r'rr_s6  - -f 55r&c.[R"U5$)a8 Return the peak size of memory that is held by the allocator of the given device. Args: device(paddle.Place|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.cuda.max_memory_reserved(paddle.CUDAPlace(0)) >>> max_memory_reserved_size = paddle.cuda.max_memory_reserved(0) >>> max_memory_reserved_size = paddle.cuda.max_memory_reserved("gpu:0") )r)max_memory_reservedr3s r'rr}s.  , ,V 44r&c.[R"U5$)a Reset the peak size of memory that is allocated to tensor of the given device. Args: device(paddle.Place|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.cuda.reset_max_memory_allocated(paddle.CUDAPlace(0)) >>> paddle.cuda.reset_max_memory_allocated(0) >>> paddle.cuda.reset_max_memory_allocated("gpu:0") )r)reset_max_memory_allocatedr3s r'rrs*  3 3F ;;r&c.[R"U5$)a Reset the peak size of memory that is held by the allocator of the given device. Args: device(paddle.Place|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.cuda.reset_max_memory_reserved(paddle.CUDAPlace(0)) >>> paddle.cuda.reset_max_memory_reserved(0) >>> paddle.cuda.reset_max_memory_reserved("gpu:0") )r)reset_max_memory_reservedr3s r'rrs(  2 26 ::r&c.[R"U5$)a\ Return the current device memory managed by the caching allocator in bytes for a given device. Args: device (DeviceLike, optional): The device to query. If None, use the current device. Can be paddle.CUDAPlace, paddle.CustomPlace, paddle.XPUPlace, int (device index), or str (device string). Returns: int: The current memory managed by the caching allocator in bytes. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # Get memory reserved for current device >>> mem_reserved = paddle.cuda.memory_reserved() >>> print(f"Memory reserved: {mem_reserved} bytes") >>> >>> # Get memory reserved for specific device >>> mem_reserved = paddle.cuda.memory_reserved(0) >>> print(f"Memory reserved on device 0: {mem_reserved} bytes") )r)memory_reservedr3s r'rrs4  ( ( 00r&cV[U[5(a[R"5n[U[R 5(aSU3nGOC[U[R 5(aUR5SU3nGO [U[R5(aSU3nO[S5e[U[5(aUnO[U[R 5(aSUR"53nO[U[R 5(a&UR"5SUR"53nOL[U[R5(aSUR"53nO[S[U5S35e[R"U5 g)a Set the current device. Args: device (DeviceLike): The device to set as current. Can be paddle.CUDAPlace, paddle.CustomPlace, paddle.XPUPlace, int (device index), or str (device string). Returns: None Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> # Set current device to GPU:0 >>> paddle.cuda.set_device(0) >>> # Set current device to GPU:0 >>> paddle.cuda.set_device('gpu:0') >>> # Set current device to a specific CUDAPlace >>> place = paddle.CUDAPlace(0) >>> paddle.cuda.set_device(place) zgpu::zxpu:zTPaddle-CPU is not supported. Please use PaddlePaddle with CUDA, XPU or Custom DevicezUnsupported device type: z9. Expected int, str, CUDAPlace, XPUPlace, or CustomPlace.N)rnrdr _current_expected_place_rrp CustomPlaceget_device_typeXPUPlacersrLrttyper) set_device)r device_place device_strs r'rrs[6&# 99; lDNN 3 3xJ  d&6&6 7 7(88:;1VHEJ  dmm 4 4xJf  FC  FDNN + +F00234 FD,, - -..0163G3G3I2JK FDMM * *F00234 'V ~5n o  Z(r&cH[U5n[R"X5nU$)a2 Wrap an externally allocated CUDA stream into a Paddle :class:`paddle.cuda.Stream` object. This function allows integrating CUDA streams allocated by other libraries into Paddle, enabling multi-library interoperability and data exchange. Note: - This function does not manage the lifetime of the external stream. It is the caller's responsibility to ensure the external stream remains valid while the returned Paddle stream is in use. - Providing an incorrect `device` may result in errors during kernel launches. Args: data_ptr (int): Integer representation of the external `cudaStream_t`. device (DeviceLike, optional): The device where the external stream was created. Can be a Paddle device string (e.g., "cuda:0"), an int index (e.g., 0), or a PaddlePlace (CUDAPlace). Default: None (current device). Returns: paddle.cuda.Stream: A Paddle Stream object that wraps the external CUDA stream. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> # Assume an external library provides a stream pointer:original_raw_ptr >>> # doctest: +SKIP('original_raw_ptr not exist') >>> original_raw_ptr = 77777 >>> external_stream = paddle.cuda.get_stream_from_external(original_raw_ptr) )r r)get_stream_from_external)data_ptrr stream_exs r'rr s%Fv &F66xHI r&)*rWrkrrrxr*r.r2r5r7rr rrrzr|rrrrrrr<r>rrrrrrr"r r!rrrrrrr rr )rebool)N)r DeviceLikererf)rrrer )rr)rrrerL)rrreztuple[int, int])r:rdrerf)rDeviceLike | Nonerecore.GeneratorState)r?rrrrerf)rjrdrerf)rerd)rerf)rrrerd)rrrerf)rrdrrrer )F __future__rtypingrrrCrrrr)r paddle.devicer r r r rrrrr$rrr0rrr9rrrpaddle.tensor.creationrrrrrrrr r!r"rqrdrLrr*r.r2r5r7r<r>rArW RuntimeErrorrYrkrxrzr|rrrrrrrrr__all__r%r&r'rs<"#' AA$   v{{((#sD89J"8#@-D*(7>1B7B!*/.AE3"3,=3 3<++D*"Z, ,0*.Z(( 0!LH2:6<54<0;.1::)|)-&&%& &R+ r&