ΑiN%SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKJ r J r J r SSK J r SSKrSSKJr SSKJrJr SSKJrJrJrJr SSKJrJrJrJrJrJ r J!r!J"r"J#r#J$r$ S S K%J&r&J'r' \ (aSS K(J)r) SS KJ*r* SS KJ+r,J-r. SSK/J0r0 SSK1J2r2 \ \Rf\Rh\Rj4r6\ \Rn\Rp\Rr4r:SSKJ;r;Jr> \ \;\<\?\@4rAS\BS'SrC\R."5(a!S SK&JDrEJFrGJHrHJIrIJJrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrT O\R"5(aS SK'JDrEJFrGJHrHJIrIJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrT Oz\V"\S5(a\R"5rXO/rX\X(a;\R"\XS5(a!S SKZJDrEJFrGJHrHJIrIJJrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrT OS rCS SK[JHrHJLrLJMrMJNrNJOrOJRrRJSrSJTrT /SQr\Sq]SQSjrYSRSjr^SSSjr+SRSjrUSTSjr-SRSjr_SRSjr`SUS jraSVSWS"jjrbSXS#jrc"S$S!5rdSYS%jreSZS[S&jjrfS\S'jrg\ SVS]S(jj5rh\ S^S)j5rhSVS_S*jjrhS`S+jriSaS,jrjSbS-jrkScS.jrWSbS/jrlScS0jrmSVSdS1jjrJSVSeS2jjrnSVSfS3jjroSVSgS4jjrpShS5jrq"S6S75rr"S8S95rsSVSiS:jjrtSVSjS;jjruSkS<jrv"S=S>5rw\wrxSlS?jry"S@SA5rzSVSmSBjjr{SnSCjr|SVSoSDjjr}SpSEjr~"SFSG5r"SHSI5r"SJSK5rSVSqSLjjr"SMSN\?5r"SOSP\GR5r\GR \r\"\\GR5r\GRGR\GR5 \\GR \'g)r) annotationsN) TYPE_CHECKINGUnionoverload) TypeAlias)autocast)core framework)is_compiled_with_cinnis_compiled_with_cudais_compiled_with_distributeis_compiled_with_rocm) BFloat16Tensor BoolTensor ByteTensor CharTensor DoubleTensor FloatTensor HalfTensor IntTensor LongTensor ShortTensor)cudaxpu)AbstractContextManager) TracebackType)IPUPlaceXPUPlace) PlaceLike)Place) CUDAPlace CustomPlace)_customDevicePropertiesr_CustomPlaceLike) create_event create_stream device_count empty_cacheget_device_properties get_rng_state manual_seedmax_memory_allocatedmax_memory_reservedmemory_allocatedmemory_reservedreset_max_memory_allocatedreset_max_memory_reserved set_rng_state) r&r'r(r)r+r,r-r.r/r0r1r2r3get_all_custom_device_type)r(r+r,r-r.r1r2r3)7get_cudnn_version set_device get_devicerris_compiled_with_xpuis_compiled_with_ipur r rr is_compiled_with_custom_deviceget_all_device_typer4get_available_deviceget_available_custom_devicer*StreamEventcurrent_stream set_stream stream_guard device_guard synchronizer(r)r-r.r1r2r/r0 is_availableis_current_stream_capturingget_device_nameget_device_capabilityr+r3rrrrrrrrrrdeviceis_bf16_supportedr,reset_peak_memory_stats ipc_collectget_stream_from_external StreamContextc.[R"U5$)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") )r r:) device_types V/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/device/__init__.pyr:r:s$  . .{ ;;c,[R"5$)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() )r r9rRrQr9r9  $ $ &&rRc,[R"5$)z Return a Graphcore IPU Place Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> paddle.device.set_device('ipu') >>> place = paddle.device.IPUPlace() )r rrTrRrQrrs ==?rRc,[R"5$)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() )r r8rTrRrQr8r8 rUrRc.[R"U5$)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) )r r)dev_ids rQrrs$ ==  rRc[5S:$)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.device.is_available(): ... print("At least one device is available") ... else: ... print("No supported devices available") r)r(rTrRrQrErE2s2 >Q rRc,[R"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.device.is_current_stream_capturing()) # True ... graph.capture_end() )r is_cuda_graph_capturingrTrRrQrFrFNs"  ' ' ))rRc[R"5(dg[c-[[R"55nUq[S:agU$[$)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)r r _cudnn_versionint cudnn_version)r`s rQr5r5bsK(  % % ' 'D..01 & A  rRrIc2[U5n[U5nU$)zQ Convert input device(Place | int | str | None) into corresponding Place object. )_device_to_paddle_convert_to_placerIs rQdevice_to_placeresv &F v &F MrRc [U[5(dU$UR5nURS5(aUR SS5nU[ R "5;aP[R"SUS3S5RS5n[US5n[ R"X5nU$US:Xa[ R"5nU$US:XdUS :Xac[ R"5(d [S 5e[ R"[ R"R%5R&5nU$US :Xaq[ R("5(d [S 5e[R"S S5RS5n[US5n[ R*"U5nU$US:Xa<[ R,"5(d [S5e[ R."5nU$[0R2"SU5=(d [0R2"SU5n[0R2"SU5nU(aa[ R"5(d[SUS35eURSS5nUSn[U5n[ R"U5nU(aa[ R("5(d[SUS35eURSS5nUSn[U5n[ R*"U5nU(dU(dURSS5nUSn U [ R "5;a(USn[U5n[ R"X5nU$[SR5SR7SSS S S/[ R "5Q5555eW$)NrgpuFLAGS_selected_s0,rcpudcuzLThe device should not be 'gpu', since PaddlePaddle is not compiled with CUDArzKThe device should not be 'xpu', since PaddlePaddle is not compiled with XPUFLAGS_selected_xpusipuzKThe 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:rz-, since PaddlePaddle is not compiled with XPUz3The device must be a string which is like 'cpu', {}z, c34# UHnSUSUS3v M g7f)'z', 'z:x'NrT).0xs rQ $_convert_to_place..s* "& s$qc-&snpu) isinstancestrlower startswithreplacer r4osgetenvsplitr_r#CPUPlacer ValueErrorr"paddle distributed ParallelEnvrYr8rr9rrematchformatjoin) rI lower_deviceselected_devices device_idplace selected_xpusavailable_gpu_deviceavailable_xpu_devicedevice_info_listrPs rQrcrcs fc " " <<>Lv&&#++FE:  002299vha%@#FLL  (+,   3R LQ   N LM  ,%"7))++? v11==?FFG@ L  ((**>  "7=CCCH  a()  i(n Lm  ((**>  ` L] "xx LA RXX  F  "xx LA --// /0D/EF-- &||C3 (+IIINN9-E ,,.. /0D/EF,, &||C3 (+IIIMM),E#,@%||C3 *1-Kd==??,Q/  N ((@ L!IPP "!& % % % & "&!@!@!B & "     LrRcF\rSrSrSrSS SjjrSrS SjrSrg) rIia0Context-manager that changes the selected device. Args: device (paddle.Place, int or str): device index to select. Examples: .. code-block:: python >>> import paddle >>> print(paddle.device.get_device()) # gpu:0 >>> with paddle.device.device("cpu"): ... print(paddle.device.get_device()) # cpu >>> # paddle.cuda.device is an alias of paddle.device.device >>> with paddle.cuda.device("cpu"): ... print(paddle.device.get_device()) # cpu >>> print(paddle.device.get_device()) Nc2[U5UlSUlg)Nz-1)rerprev_place_strselfrIs rQ__init__device.__init__s$V, "rRcL[5Ul[UR5 gN)r7rr6rrs rQ __enter__device.__enter__s(l4::rRc.[UR5 gNF)r6r)rexc_type exc_value tracebacks rQ__exit__device.__exit__s 4&&'rR)rrr)rIPlace | int | str | None)rtype[BaseException] | NonerBaseException | Nonerztypes.TracebackType | Nonereturnz bool | None) __name__ __module__ __qualname____firstlineno____doc__rrr__static_attributes__rTrRrQrIrIs<&#,(.   rRch[5nSU;a[URS5S5nU$SnU$)a Return the index of a currently selected device. Returns: int: The index of the currently selected device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> device_id = paddle.device.current_device() # this is equivalent to paddle.cuda.current_device() >>> print(f"Current device index: {device_id}") rprr)r7r_r) device_strrs rQcurrent_devicer sD J j ((-a01  rRc[R"[RR 55(ag[ 5(dg[ 5nU(dg[R"S/[RUS9 g! g=f)aa Return a bool indicating if the current CUDA/ROCm device supports dtype bfloat16. Args: including_emulation (bool = True): Whether to treat software-emulated BF16 as supported; if False, only native hardware BF16 support is considered. Returns: bool: A boolean value which indicates whether the current CUDA/ROCm device supports dtype bfloat16. Examples: .. code-block:: python >>> import paddle >>> paddle.device.is_bf16_supported() >>> # paddle.cuda.is_bf16_supported() is an alias of paddle.device.is_bf16_supported() >>> paddle.cuda.is_bf16_supported() TFg?)dtyperI) r is_bfloat16_supportedrr _current_expected_place_rEr7tensorbfloat16)including_emulationrIs rQrJrJ'sj, !!&"2"2"K"K"MNN >> \F  se6??6Bs %BBcH[U5n[R"U5 U$)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, Place or int): 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 >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device("cpu") >>> x1 = paddle.ones(name='x1', shape=[1, 2], dtype='int32') >>> print(x1.place) Place(cpu) >>> paddle.device.set_device("gpu:0") >>> x2 = paddle.zeros(name='x2', shape=[1, 2], dtype='int32') >>> print(x2.place) Place(gpu:0) >>> # x1 is still on cpu >>> print(x1.place) Place(cpu) )rer _set_expected_placerIrs rQr6r6Ss"H F #E !!%( LrRcgrrTinputs rQr7r7|s+.rRcgrrTrs rQr7r7s-0rRcX[U[R5(a4S[UR5;agURR 5$Sn[ R"5n[U[R5(aSnU$[U[R5(a UR5nS[U5-nU$[U[R5(a UR5nS[U5-nU$[U[R5(a [R"5nSUS- S3nU$[U[R5(a3UR5nUR!5nUS -[U5-nU$[#S US 35e) 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. Returns: if input is Tensor, this function will return the device ID where the given Tensor is located. int: - -1, if the Tensor is on CPU. - The device ID (e.g., 0, 1, ...) if the Tensor is on GPU. if input is not Tensor, this function will return the device name where the program is running. str: - 'cpu': If the program is running on CPU. - 'gpu:x': If the program is running on GPU, where `x` is the index of the GPU. - 'xpu:x': If the program is running on XPU, where `x` is the index of the XPU. - 'npu:x': If the program is running on NPU, where `x` is the index of Examples: .. code-block:: python >>> import paddle >>> device = paddle.device.get_device() >>> x_cpu = paddle.to_tensor([1, 2, 3], place=paddle.CPUPlace()) >>> id = paddle.get_device(x_cpu) # -1 rlgpu:zxpu:zipus:{0-r}rpzThe device specification z is invalid)rxrTensorryr gpu_device_idr rr rr" get_device_idrrget_ipu_device_countr#get_device_typer)rrIrr num_devicesrPs rQr7r7svB%'' C $ ${{((** F  . . 0E%''" M! E4>> * *'') #i.( M E4== ) )'') #i.( M E4== ) )//1 [1_-R0 M E4++ , ,'') ++- s"S^3 M4UG;GHHrRc^[R"[5RSS55$)z Returns: str: The default device for PaddlePaddle. Example: .. code-block:: pycon >>> import paddle >>> print(paddle.get_default_device()) rgr)rrIr7r|rTrRrQget_default_devicers" ==--eV< ==rRc[U5 g)a Paddle supports running calculations on various types of devices, including CPU, GPU, XPU, NPU and IPU. This function can specify the global device which the OP will run. Args: device(str, Place or int): 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. Examples: .. code-block:: python >>> import paddle >>> paddle.device.set_device("cpu") N)r6rds rQset_default_devicers vrRc,[R"5$)a 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: [] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: ['gpu'] >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered. >>> # Output: ['CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['gpu', 'CustomCPU', 'CustomGPU'] )r r;rTrRrQr;r;s6  # # %%rRc,[R"5$)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'] )r r4rTrRrQr4r4s*  * * ,,rRc,[R"5$)a 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: [] >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered. >>> # Output: ['gpu:0', 'gpu:1'] >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered. >>> # Output: ['CustomCPU'] >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered. >>> # Output: ['gpu:0', 'gpu:1', 'CustomCPU', 'CustomGPU:0', 'CustomGPU:1'] )r r<rTrRrQr<r<s6  $ $ &&rRc,[R"5$)a 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'] )r r=rTrRrQr=r=5s*  + + --rRc.[U5n[U5$)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) )rb_get_device_propertiesrds rQr*r*Ms:v &F !& ))rRcd[U5n[U[5(aUR5R S5Sn1SknUS;a[ R $US:Xa[ RR$X;a[ RR$US:Xa[ RR$[SU35eUc[ RR5O [U5n[R [ R [R"[ RR[R$[ RR[R&[ R0nUR)5HupE[X$5(dMUs $ g) aD Returns the Paddle module associated with a given device. Args: device (_CustomPlaceLike, optional): The device to query. Can be one of the following: - paddle.Place object (e.g., paddle.CUDAPlace(0)) - str (e.g., "gpu:0", "xpu", "npu") - int (device index, e.g., 0 -> "gpu:0") - None (use current expected place) Returns: module: The corresponding Paddle device module (e.g., paddle.cuda, paddle.device.xpu) Raises: RuntimeError: If the device type is CPU (Paddle does not expose `paddle.cpu`) or if no matching device module is found. Example: .. code-block:: python >>> paddle.get_device_module("gpu:0") >>> # paddle.get_device_module(paddle.XPUPlace(0)) >>> # rpr> gcumlumpsrwsdaa biren_gpu intel_gpu intel_hpu metax_gpu custom_cpu iluvatar_gpu)rrgrrlUnsupported device type: N)rbrxryrzrrrrIr custom_devicerl RuntimeErrorr rrcr r"r#rritems)rIcustom_device_typesrplace_to_module place_typemodules rQget_device_modulernsD6v &F&#%%c*1-   _ $;;  u_==$$ $  *==.. . u_==$$ $!:6(CD D > 113 v &    &--55 v}}(( v}} O.335 e ( (M6rRc,[U5R$)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: str: The name of the CUDA device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> name = paddle.device.get_device_name() >>> print(name) )r*namerds rQrGrGs0 ! ( - --rRcH[U5nURUR4$)aC Return the device_capability 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: str: The device_capability of given device. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> cap = paddle.device.get_device_capability() >>> print(cap) )r*majorminor)rIprops rQrHrHs!0 ! (D ::tzz !!rRc Uc[R"5$[U[5(aUn[R"5(aSnGOSn[R "5n[ U5S:Xa!US:XaUSnOD[SUSUSS35eUH)nURS5upg[U5U:XdM'UnM+ Uc[SUS U35eO[U[R5(aSnUR5nO[U[R5(a!UR5nUR5nO[U[5(a]URS 5(a[US S5nOJSU;a URSS5up8[U5nO$[S US US35e[SUS US35eUS:d SUS35e[R"5(a&U[5:dSUS[535eU$U[R "W5:d$SUSUS[R "U535eU$)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. Nrgrrz Device id z) not found in available_custom_devices: [z:0]rpz( not found in available_custom_devices: rzThe 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 )r get_cuda_current_device_idrxr_r r=lenrrr"rr#rryr{r(get_custom_device_count) rIop_namerrPavailable_custom_devicesddev_typerY device_id_strs rQextract_device_idrs~..00&#  % % ' 'KK'+'G'G'I $+,1Q;":1"=K$$VH,UVnopVqUrruv2A'(wws|$H6{f,&. 2"  (PQiPjk# FDNN + + ((* FD,, - -,,. ((* FC   V $ $F12JI 6M)/c1)= &KM*I%fX-GyQ99  vh&@ J5 5  > >ykK> !!##<>) YK'@@P Q ) 477 DD YKy =QRVRnRnozR{Q| } D rRc\rSrSr%SrS\S'S\S'S\S'SSS jjrSSS jjrSS jrSS jr SSjr SSjr Sr g )r?i;a A device event wrapper around StreamBase. Args: 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. Note: The `device` parameter has been removed in the latest version. The event will always use the current device context. Previously, you could specify the device like: ```python # Old usage (no longer supported) e = paddle.device.Event(device="gpu:0") ``` Now it will automatically use the current device: ```python # New usage paddle.set_device("gpu:0") # Set device first e = paddle.device.Event() # Will use gpu:0 ``` paddle.device.Event is equivalent to paddle.cuda.Event. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:CUSTOM_DEVICE) >>> import paddle >>> paddle.set_device('custom_cpu') >>> e1 = paddle.device.Event() # Uses current device (custom_cpu) >>> >>> # Old usage (no longer supported): >>> # e2 = paddle.device.Event('custom_cpu') >>> # e3 = paddle.device.Event('custom_cpu:0') >>> # e4 = paddle.device.Event(paddle.CustomPlace('custom_cpu', 0)) >>> >>> # New equivalent usage: >>> paddle.set_device('custom_cpu:0') >>> e5 = paddle.device.Event() # Uses custom_cpu:0 PlaceLike | NonerIbool enable_timing_InitEventBase event_basecJ[RR5Ul[ URS5(aURR 5OSn[ URS5(aURR 5OSn[UUUUUS9Ulg)Nrr)rblocking interprocessrPr) rr rrIhasattrrr_create_event_baser)rrrrrrPs rQrEvent.__init__ps &&??A t{{O44 KK % % ' t{{$566 KK ' ' )  -'%#  rRNc~Uc[UR5nURRUR5 g)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@rIrrecord stream_baserstreams rQr Event.records/4 >#DKK0F v112rRc6URR5$)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() )rqueryrs rQr  Event.querys($$&&rRcLURRUR5$)a 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)r end_events rQrEvent.elapsed_times0++I,@,@AArRc8URR5 g)a 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)rrDrs rQrDEvent.synchronizes, ##%rRc<SURSURS3$)Nz Event(device=z , event_base=)rIrrs rQ__repr__Event.__repr__s t{{m=8IKKrRr)FFF)rrrrrrrNonerr  Stream | Nonerrrr)rr?rr_rrrry) rrrrr__annotations__rrr rrDrrrTrRrQr?r?;sm.` $"        63>',B4&0LrRr?c^\rSrSr%SrS\S'S\S'SSSSS .rS \S 'SSS jjrSS jrSSjr SSSjjr SSjr SSjr \ S5rSrS U4SjjrS!SjrS"SjrSrU=r$)#r>iaZ A device stream wrapper around StreamBase. paddle.cuda.Stream() is equivalent to paddle.device.Stream(). 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 or -1 (high priority) or 0 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)) _InitStreamBaserPlaceLike | intrIr)rrrr$zdict[int, int] _priority_mapc"Uba[U[R[R[R45(aX0lUR Ulg[S5e[U5Ul[URS5(aURR5OSn[URS5(aURR5OSnURRUS5n[UUSUS9Ulg)Nz?stream_base should be CUDAStream, XPUStream, CustomDeviceStreamrrr$F)rpriorityrrP)rxr CUDAStreamCustomDeviceStream XPUStreamrrrI TypeErrorrerrrr%get_create_stream_base)rrIr'rrrPs rQrStream.__init__s  "$"9"94>>J$/ )//  U&f- t{{O44 KK % % ' t{{$566 KK ' ' )  %%))(A6.#  rRcNURRUR5 g)a 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_eventrrevents rQr0Stream.wait_event?s2 ##E$4$45rRcNURRUR5 g)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_streamr s rQr5Stream.wait_streamZs2 $$V%7%78rRcBUc [5nURU5 U$)a 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) )r?rr1s rQ record_eventStream.record_eventus!4 =GE T rRc6URR5$)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() )rr rs rQr  Stream.querys&%%''rRc8URR5 g)a1 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)rrDrs rQrDStream.synchronizes& $$&rRc[UR[R5(a*[R "URR 5$[UR[R5(a*[R "URR5$[R "URR5$r) rxrr r(ctypesc_void_p cuda_streamr* xpu_stream raw_streamrs rQ_as_parameter_Stream._as_parameter_s d&& 8 8??4#3#3#?#?@ @ (($.. 9 9??4#3#3#>#>? ???4#3#3#>#>? ?rRc2SURR4$)z CUDA Stream protocol described at https://nvidia.github.io/cuda-python/cuda-core/latest/interoperability.html#cuda-stream-protocol Returns a tuple of (protocol_version, cudaStream_t) r)rrCrs rQ__cuda_stream__Stream.__cuda_stream__s4##..//rRcN>[U[5(a[TU] U5$gr)rxr>super__eq__)ro __class__s rQrK Stream.__eq__s" a 7>!$ $rRcD[URUR45$r)hashrrIrs rQ__hash__Stream.__hash__sT%%t{{344rRcRSURSURRSS3$)Nz)rIrDvaluers rQrStream.__repr__s,.t{{m8DDWDWD]D]^`CaabccrR)rIr)Nr$N)rIPlaceLike | int | Noner'r_rz_InitStreamBase | Nonerr)r2r?rr)r r>rrr)r2z Event | Nonerr?rr)rLrrrrr_r)rrrrrr r%rr0r5r8r rDpropertyrDrGrKrQrr __classcell__)rMs@rQr>r>s<! )*qQ1$=M>=*..2 $ &$ $ , $  $ L6696>(*'*@@0 5ddrRr>cp[U[5(aTUS:a[SU35e[5nUS:XaUS:wa[SU35egUR S5SnUSU3$[U[ 5(a*UR 5nSU;aURSS5$U$Uc [5$U$)Nrz'Device index must be non-negative, got rlz&CPU device only supports index 0, got rpzcuda:r)rxr_rr7rrystripr|)dev current_placerPcleaned_devices rQrbrbs#s 7FseLM M" E !ax #I#!OPP#))#.q1 au%% C  .(  " "7F 3   | rRcUc[RR5nO7[U[5(a [R R U5nOUn[R"5(aJ[U[R5(a+[[R"UR55S9$[R"5(aJ[U[R5(a+[[R"UR55S9$[U[R 5(a:[[R""UR%5UR55S9$['SR)SR+[R R-5555e)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) rdevice should be gpu, xpu, {}rk)rr rrxryrIrcr r"r>r _get_current_streamrr8r_xpu_get_current_streamr#!_get_current_custom_device_streamrr+rrr4rs rQr@r@sJ4~  99; FC  //7 ##%%*UF>%%')<)<)>   + 2 2AACD   rRc[URR5n[R"5(aU[ URR[R 5(a"[R"UR5 U$[R"5(a_[ URR[R5(a,[R"URR5 U$[ URR[R5(ah[R"URRR5URRR!5UR5 U$[#SR%SR'[R(R+5555e)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.cuda.set_stream(s) is equivalent to paddle.device.set_stream(s) >>> paddle.device.set_stream(s) rbrk)r@rrrr rxr"r _set_current_streamr8r_xpu_set_current_streamidxr#!_set_current_custom_device_streamrrr+rrrIr4)r  prev_streams rQrArA-sf0!!3!3!9!9:K ##%%*  &"2"2++   !3!34$ #  $ $ & &:  &//,, $$V%7%7%;%;<  F&&,,f.@.@ A A ..    $ $ 4 4 6    $ $ 2 2 4       + 2 2AACD   rRcV\rSrSr%SrS\S'S S SjjrS SjrS SjrS r g)rBi_aL 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):# this is equivalent to paddle.cuda.StreamContext(s) and paddle.device.StreamContext(s) ... s.wait_stream(paddle.device.default_stream()) # type: ignore[attr-defined] ... data4 = data1 + data3 rr NcXlgrr r s rQrstream_guard.__init__s rRcURnUcg[UR5UlURRUR:wa[R R R5Ul[R R RUR5 [UR5Ul [U5 g[U5 gr) r r@rIsrc_prev_streamrbaser r tmp_placerdst_prev_streamrA)r cur_streams rQrstream_guard.__enter__s[[   -j.?.?@    & &**;*; ;#[[22KKMDN KK ! ! 5 5j6G6G H#1*2C2C#DD z " z "rRcRURnUcgURRUR:wa^[UR5 [ R RRUR5 [UR5 g[UR5 gr) r rqrIrArtrrrr rrs)rrexc_valexc_tbrus rQrstream_guard.__exit__sv [[       & &**;*; ; t++ , KK ! ! 5 5dnn E t++ , t++ ,rR)rtrqr rsrrrrrrxrryzTracebackType | Nonerr rrrrrr rrrrrTrRrQrBrB_sD:  #-,-&-% -  -rRrBc[U5$)a 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('cuda') >>> s = paddle.device.Stream() >>> data1 = paddle.ones(shape=[20]) >>> data2 = paddle.ones(shape=[20]) >>> data3 = data1 + data2 >>> with paddle.device.stream(s): # this is equivalent to paddle.cuda.stream(s) ... s.wait_stream(paddle.cuda.current_stream()) ... data4 = data1 + data3 >>> print(data4) )rNrns rQr r s>   rRc\\rSrSr%SrS\S'S\S'S SjrS SjrS SjrS r g )rCia 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_placec[U[5(a%[RR U5Ulg[U[R RR5(aXlg[S[U535e)Nz_'device' must be a string or an instance of a subclass of paddle.base.libpaddle.Place, but got ) rxryrrIrcrrr libpaddler!rtypers rQrdevice_guard.__init__sj fc " "!'!@!@!HD   5 5 ; ; < >> # 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) Nrbrk)rr rrxryrIrcr r"r _device_synchronizerr8r_xpu_device_synchronizer#_synchronize_custom_devicerr+rrr4rs rQrDrD s$~  99; FC  //7 ##%%*UF>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> # Force collect expired IPC memory >>> paddle.device.ipc_collect() #this is equivalent to paddle.cuda.ipc_collect() N)rrrr _ipc_collectrTrRrQrLrL2s  KK&&(rRc Uc[RR5nO7[U[5(a [R R U5nOUn[[R"XR55S9$)aT Return a :class:`Stream` from an externally allocated CUDA stream. This function is used to wrap streams allocated in other libraries in order to facilitate data exchange and multi-library interactions. .. note:: This function doesn't manage the stream life-cycle, it is the user responsibility to keep the referenced stream alive while this returned stream is being used. Args: data_ptr(int): Integer representation of the CUDA stream handle (``cudaStream_t``) that is allocated externally. device(str|paddle.CUDAPlace(n), optional): The CUDA device where the stream was originally allocated. If device is None, the current CUDA device is used. It can be ``gpu``, ``gpu:x``, or ``paddle.CUDAPlace(n)``. Returns: Stream: The wrapped CUDA stream corresponding to the given external pointer. Examples: .. code-block:: python >>> import paddle >>> # doctest: +SKIP('original_raw_ptr not exist') >>> original_raw_ptr = 77777 >>> external_stream = paddle.device.get_stream_from_external(original_raw_ptr,"cuda:0") ra) rr rrxryrIrcr>r _get_stream_from_externalr)data_ptrrIrs rQrMrMEskB~  99; FC  //7 22 ))+  rRc0[R"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.device.manual_seed_all(102) N)rseed)rs rQmanual_seed_allrts$ KKrRcH\rSrSr\S\R S4SSjj5rSrg) _AutocastModeiTc[SXS9$)a Create a context which enables auto-mixed-precision(AMP) of operators executed in dynamic graph mode. If enabled, the input data type (float32, float16 or bfloat16) of each operator is decided by autocast algorithm for better performance. Commonly, it is used together with `GradScaler` and `decorator` to achieve Auto-Mixed-Precision in imperative mode. Args: device_type(str, optional): Device type. But because the paddle does not distinguish between devices, this parameter does not work. enable(bool, optional): Enable auto-mixed-precision or not. Default is True. dtype(str, optional): Whether to use 'float16' or 'bfloat16'. Default is 'float16'. cache_enabled(bool, optional): whether to enable cache or not. Default is True. But this parameter is not used Note: paddle.cuda.amp. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> conv2d = paddle.nn.Conv2D(3, 2, 3, bias_attr=False) >>> data = paddle.rand([10, 3, 32, 32]) >>> with paddle.device.amp.auto_cast(): ... conv = conv2d(data) ... print(conv.dtype) >>> # doctest: +SKIP("This has diff in xdoctest env") paddle.float16 >>> # doctest: -SKIP >>> with paddle.device.amp.auto_cast(enable=False): ... conv = conv2d(data) ... print(conv.dtype) >>> # doctest: +SKIP("This has diff in xdoctest env") paddle.float32 >>> # doctest: -SKIP r)rPenabledr) _autocast)rr cache_enableds rQr_AutocastMode.autocasts\VWJJrRrTN)rr) rrrr staticmethodrfloat16rrrTrRrQrrs*FNN$-K -K-KrRrcJ\rSrSrSr\"\R5r\"5rSr g)ampiz$Namespace for amp marker operations.rTN) rrrrrrrr autocast_moderrTrRrQrrs.M223H!OMrRrc<\rSrSrSr\SSj5r\S5rSrg)nvtxiz%Namespace for NVTX marker operations.cV[RRRU5 g)aj 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.device.nvtx.range_push("test") N)rrrr nvprof_nvtx_push)msgs rQ range_pushnvtx.range_pushs  ))#.rRcT[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.device.nvtx.range_pop() N)rrrr nvprof_nvtx_poprTrRrQ range_popnvtx.range_pops  ((*rRrTN)rry) rrrrrrrrrrTrRrQrrs+///" + +rRrc[5 g)a Resets all devices' peak memory statistics. This method resets the peak memory usage recorded for each device during the execution of the program. It sets the peak memory usage back to zero for all devices. Example: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') # or '' >>> # paddle.cuda.reset_max_memory_allocated() is equivalent to paddle.device.reset_max_memory_allocated() >>> paddle.device.reset_max_memory_allocated(paddle.CUDAPlace(0)) >>> paddle.device.reset_max_memory_allocated(0) >>> paddle.device.reset_max_memory_allocated("gpu:0") N)r1rds rQrKrKs ( rRcz\rSrSrSr/r1SkrS SSjjr\S5r \S5r SSjr SS jr S r S rS rg)Deviceia Paddle computing device. This class represents a computing device in Paddle, such as CPU, GPU (CUDA), or XPU, and can be passed directly to Paddle tensor creation APIs. Note: - Only device types "cpu", "gpu", "cuda", and "xpu" are supported. - The string representation of the device (e.g., "cuda:0") can be used directly in Paddle APIs that accept a device argument. - This class supports context manager usage to temporarily set the default device. Args: type (str|int, optional): The device type or a legacy device index. - str: "cpu", "cuda", "cuda:0", "gpu:1", "xpu:0" - int: legacy, interpreted as the default GPU device index index (int, optional): The device index, used with `type` string. Ignored for CPU. Attributes: type (str): Device type ("cpu", "cuda", "gpu", "xpu"). index (int|None): Device index. None for CPU. Examples: .. code-block:: python >>> import paddle # String initialization >>> d1 = paddle.device("cpu") >>> d2 = paddle.device("cuda:0") >>> d3 = paddle.device("xpu", 1) # Type + index initialization >>> d4 = paddle.device(type="cuda", index=0) # Legacy int initialization >>> d5 = paddle.device(0) # equivalent to paddle.device("cuda", 0) # Copy from another device >>> d6 = paddle.device(d2) # Using as context manager >>> with paddle.device("cuda:1"): ... x = paddle.zeros([2, 3]) # created on CUDA device 1 >>> print(d2.type) # "cuda" >>> print(d2.index) # 0 >>> print(d1) # "cpu" >>> print(d2) # "cuda:0" >rlrgrrNc[U[RRR5(aUR 5(aSnSnGOUR 5(aSnUR5nGO]UR5(aSnUR5nGO4UR5(a!UR5nUR5nO[SU35e[U[5(aUR5nXPR;aSU;a[SU35eUb UnUS:waUOSnOSU;aLUR!S5up6UR5nX0R;a[SU35e[#U5nOFUnUS:waSOSnO9[U["5(aSnUnOUcUb [S5e[%S U35eUS:waUSU3OSn[R'X5nX8lXHlU$) NrlrrzUnknown place type: rprrz/Device type must be specified if index is givenzUnsupported type for Device: )rxrrrrr! is_cpu_place is_gpu_placer is_xpu_placeis_custom_placerrrryrz_SUPPORTED_TYPESrr_r+__new__ _dev_type_index) clsrindexr dev_indextririobjs rQrDevice.__new__4s dFKK1177 8 8  ""  ""$$! ..0 ""$$  ..0 %%''//1 ..0  #7v!>?? c " " A,,,A #rgrrr)rr rr"rrrrs rQ _to_placeDevice._to_placeqso 99 ==? " YY/ )>>$**- - YY% ==, ,8 DE ErRc>UR5R5$r)r__dlpack_device__rs rQrDevice.__dlpack_device__{s~~1133rRc[R"5n[RR U5 [R "[ U55 U$r)rr7r_DEFAULT_DEVICE_STACKappendr6ry)rrs rQrDevice.__enter__~s;**,$$++N;#d)$ rRcl[RR5n[R"U5 gr)rrpoprr6)rrrxryprevious_devices rQrDevice.__exit__s$ 66::</*rRrT)NN)rrWr int | None)rz core.Place)rtuple[int, int])rrrrrrrrrYrrrrrrrrTrRrQrrsp1f4GK3)39C3jF4 +rRrc,\rSrSrSrSSjrSSjrSrg) _DeviceModuleiz Device(...)c[U0UD6$r)r)rargskwargss rQ__call___DeviceModule.__call__st&v&&rRc[R"URSU35n[XU5 U$![an[ U5UeSnAff=f)Nr) importlib import_modulersetattrModuleNotFoundErrorAttributeError)rrmodes rQ __getattr___DeviceModule.__getattr__sR .))T]]O1TF*CDC D $J" . &A - .s25 A A  ArTN)rr)rry)rrrrrrrrrTrRrQrrsF'.rRr)rPryrrr)r _IPUPlace)rYr_r _XPUPlace)rrr)rIrrr!)rIr rr!rX)T)rrrr)rIr#rr )rrrry)rz paddle.Tensorrr_)rzpaddle.Tensor | Nonerz str | int)rz paddle.device)rIr#rr)rz list[str])rzlist[str] | None)rI_CustomPlaceLike | Nonerr$)rIr%)rIrrry)rIrrr)rIr%rryrr_)r]r)rIrrr>)r r>rr>)r rrrB)rIrrrr)rr_rIrrr>)rr_rr)rIrWrr) __future__rr?rr}rsystypestypingrrrtyping_extensionsrr paddle.amprr paddle.baser r paddle.base.frameworkr r r rpaddle.tensor.creationrrrrrrrrrrrrr contextlibrrrrrrpaddle._typing.device_liker paddle.base.corer!r(r)r*r" CUDAEventCustomDeviceEventXPUEventrr"r#paddle.base.libpaddler$ryr_r%r current_device_is_cpur&rr'r-r(r)r*rr+r,r-r.r/r0r1r2r3r8rr4 dev_typesr:rrl__all__r^r9rErFr5rercrIrrJr6r7rrr;r<r=rrGrHrr?r>rbr@rArBrNr rCrDrLrMrrrrrKr ModuleTypermodulesr_selfr_proxy__dict__updaterTrRrQrs #  11' ,'    1#C4& 00$..@O .. =N.="'   #i     t122335  T881FF     "!" 8 t<*'"$'"!*8*(BUp##L:)X&R . . 0 09x >&&<-0'<.2'+* #**BER'+. #..8'+" #""8K\xLxLvcdcdN%) !44 n/d@-@-F !D?G?GD& R)(/3,,+, ,^*/K/Kd$$!+!+H!.I+SI+X .E$$ . H x /u~~& HrR