iUddlZddlZddlZddlZddlmZddlmZddlm Z m Z m Z ddl Z ddl mZddlmZddlmZmZmZddlmZd d gZes:ddlZGd d Zd Zeej6d_eej6d_yddlmZ ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ej\e/Z0e r ddl1m2Z2e5e6dze jndzfZ8e jrjuegGddejvZ<e<Z=ed<d"de6fdZ?Gdd Z d#de@eAe6ze6e jnze5e6e jnfzfdeAde5e6dfdzdee8fdZBdddde6d e5eAdfde5e6dfdzde@eAe6ze6e jnze5e6e jnfzfdzdef d!Zy#e3$re0jidYwxYw)$N)Iterator) zip_longest)Optional TYPE_CHECKINGUnion) is_available) _MeshLayout)IntTupleis_intsuffix_product)not_noneinit_device_mesh DeviceMeshc eZdZy)_DeviceMeshStubN)__name__ __module__ __qualname__W/var/www/html/engine/venv/lib/python3.12/site-packages/torch/distributed/device_mesh.pyrrs rrcyNrrrr_init_device_mesh_stubr s rztorch.distributed.device_mesh)Backend) _get_default_group_resolve_process_group get_backendget_process_group_ranksget_rankget_world_size GroupNameinit_process_groupis_initialized new_group ProcessGroup split_group) ArrayLikezCDeviceMesh requires numpy >= 1.21 to be installed for type checkingcreZdZd dZddZddZededefd Z ededefd Z ddd ede dfd Z y)_MeshEnvreturnNcg|_yr) mesh_stackselfs r__init__z_MeshEnv.__init__Is 02DOrrcft|jdk(r td|jdS)Nrz#No device mesh is currently active!)lenr- RuntimeErrorr.s rget_current_meshz_MeshEnv.get_current_meshLs.4??#q("#HII??2& &r device_meshcXtjdd|s|S|jS)NzdThis get_root_mesh API will be deprecated soon.Please use `get_root_mesh` inside DeviceMesh instead. stacklevel)warningswarn_get_root_mesh)r/r6s r get_root_meshz_MeshEnv.get_root_meshRs3 MMH  ""--/ /r device_typec4t|jSr)_get_device_handle device_countr?s rnum_devices_per_hostz_MeshEnv.num_devices_per_host`s%k2??A ArcBttj|zSr)r!r*rDrCs r num_hostsz_MeshEnv.num_hostsds"#x'D'D['QQ Qr mesh_dim_namecRtjdd|j|S)NznThis _get_all_submeshes API will be deprecated soon.Please use `_get_all_submeshes` inside DeviceMesh instead.r8r9)r;r<_get_all_submeshes)r/r6rGs rrIz_MeshEnv._get_all_submeshesls, MMM  11-@ @rr+Nr+r)r6rr+r) rrrr0r5r> staticmethodstrintrDrFlistrIrrrr*r*Hs 3 ' 0  Bc Bc B  B  R3 R3 R  R A+ Aeedfdeedfdeeedze4jjdzfdfddf d?Z7 dCd=eezd>eedfdeedfde eee4jjzeee4jjfzfdzddf d@Z8edAedddfdBZ9y)HraX DeviceMesh represents a mesh of devices, where layout of devices could be represented as a n-d dimension array, and each value of the n-d dimensional array is the global id of the default process group ranks. DeviceMesh could be used to setup the N dimensional device connections across the cluster, and manage the ProcessGroups for N dimensional parallelisms. Communications could happen on each dimension of the DeviceMesh separately. DeviceMesh respects the device that user selects already (i.e. if user call `torch.cuda.set_device` before the DeviceMesh initialization), and will select/set the device for the current process if user does not set the device beforehand. Note that manual device selection should happen BEFORE the DeviceMesh initialization. DeviceMesh can also be used as a context manager when using together with DTensor APIs. .. note:: DeviceMesh follows SPMD programming model, which means the same PyTorch Python program is running on all processes/ranks in the cluster. Therefore, users need to make sure the `mesh` array (which describes the layout of devices) should be identical across all ranks. Inconsistent `mesh` will lead to silent hang. Args: device_type (str): The device type of the mesh. Currently supports: "cpu", "cuda/cuda-like". mesh (ndarray): A multi-dimensional array or an integer tensor describing the layout of devices, where the IDs are global IDs of the default process group. _rank (int): (experimental/internal) The global rank of the current process. If not provided, it will be inferred from the default process group. Returns: DeviceMesh: A :class:`DeviceMesh` object representing the device layout. The following program runs on each process/rank in an SPMD manner. In this example, we have 2 hosts with 4 GPUs each. A reduction over the first dimension of mesh will reduce across columns (0, 4), .. and (3, 7), a reduction over the second dimension of mesh reduces across rows (0, 1, 2, 3) and (4, 5, 6, 7). Example:: >>> # xdoctest: +SKIP("no rank") >>> from torch.distributed.device_mesh import DeviceMesh >>> >>> # Initialize device mesh as (2, 4) to represent the topology >>> # of cross-host(dim 0), and within-host (dim 1). >>> mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1, 2, 3],[4, 5, 6, 7]]) _device_type _rank_map.N_mesh_dim_names_layout _root_mesh_flatten_mappingT)mesh_dim_namesbackend_override _init_backend_rankrXrVrYr?meshr(r[r\r]r^r+ctjjd||| tdt |tj r'|j jdk7rtd|t |tj r<|jjtjjn%tj|dtj} t| j| j!}| j#}n|| td|j%sJd|j&d k(sJd |j)sJd |j+|j-k\sJd |j+d |||_||_||_|r t5|nd|_| |_|dt;|j0z}nOt;|t;|j0k7r.tdt;|dt;|j0d|r|n;t|j<j|j<j!|_|j0j%s t?d|j0j+|j<j+k7r4t?d|j0d|j<jdt5|j2jA|_!d|_"i|_#|dk7r|rG|jI|jK|j0|j2|j6||_&tOr&tQdk(rtSjT|_"| tW}|j<|k(jY} | jddvrt?d| jd| jddkDr| djAnd|_-yy)Nz1torch.distributed.device_mesh.DeviceMesh.__init__z@Cannot provide _layout and/or _rank_map if passing explicit meshcpuz!`mesh` must be a CPU tensor, got dtypedevicercz>Q& L(L L&**, O.O O,??$(88 ():(;<77>iA 8 !,D "DL&DN>+@+@+B%CD ""DO$&D !e#!668,0,E,E ,,( -D)"# (C&/&9&9&;DO=$JE $yyE1::< ##A&f4(B;CSCSTUCVBWX0;/?/?/BQ/FKN))+D'5$rc|jS)z$Returns the device type of the mesh.)rUr.s rr?zDeviceMesh.device_type,s$$ $rc|jj|j}|jddk(r|dS|t k(j }|jddkDr||dSt d)z6Returns the tensor representing the layout of devices.rrf)rrzIn order to get the mesh Tensor of a DeviceMesh it needs to either have all its original dimensions (e.g., no slicing) or it needs to contain the local rank)rXremap_to_tensorrVrxr rr4)r/ full_mesh my_coordss rr_zDeviceMesh.mesh1s~ 44T^^DI~~a A% |#"hj099;I~~a 1$ 4118 rc|jS)z%Returns the names of mesh dimensions.)rWr.s rr[zDeviceMesh.mesh_dim_names@s'' 'rc t}|s tt}|jj |kDr*t d|d|jj dt |j}|r|jsdtjvrMttjd}tjd||j|t%Stjdd|j!}||kDr'||zd k7rt d |d |d |jd |jt#|zt%S)Nz2Mesh should not be bigger than default world size z , but found z ranks! LOCAL_RANKzESetting default device for the current process based on LOCAL_RANK=%sa=It seems like you did not set/select the default device for the current process before the DeviceMesh initialization or use a launcher (i.e. torchrun) which populates `LOCAL_RANK` environment variable. It is recommended to set the current device for the process BEFORE the DeviceMesh initialization so that the underlying communicator (i.e. NCCL) can be initialized properly. Given that the current process has no default device selected, DeviceMesh will use a heuristic to set the device_id via `global_rank % num_devices_per_host`, assuming homogeneous hardware cluster. r8r9rz8DeviceMesh only support homogeneous hardware, but found z ranks and  z devices!)r$r#r!rXr~r4rArUosenvironrNloggerinfo set_devicer;r<rBr r)r/default_initialized world_size device_handle local_rankrDs rrz(DeviceMesh._setup_world_group_and_deviceEsh"0"2 '"$')J||!!#j0"H T`aeamamasasau`vv}~ /t/@/@AM]%A%A%C 2::-!$RZZ %=!>JKK_"",,Z80&' '-MMv $%,9+E+E+G("%99&)==B*V)l+6J5K1TM^M^L__hj",,XZ:N-NO%' 'r sub_layoutrank_mapdim_namec|jj|}|\}}|r |jnd}d|}d} t} |j t k(ru|dk(rpt tt } tjjr(t| dk(rtd| d} | jS| } | jSt| ddtjjra|5| jtj dj#|k(r*t%| |||j'| } | jSd} |D]W} | j'}t||||| } t)|vs0| t+d t)d |d | j} Y| S)Nmesh_rhgloozcpu:gloo,cuda:nccl mesh_default)backendranks group_descbound_device_idcuda) parent_pgtimeout pg_options split_ranksr)rrrrrzFEach device mesh dimension should get only one process group, but got z in !)nestr_timeoutrr~r!rOrangerSrrrr% group_namerR _get_backendrenamer'rr r4)rrrr\pg_ranks_by_dimrrrr dim_group default_grouprpg_namedim_meshsubgroup_rankss r_init_one_process_groupz"DeviceMesh._init_one_process_groupxs)oo/??IO"2 GZ.8j))TG ! +JI.0M!^%55:JO; U>#345zz..0#M2f<  4##1!+++'!+++ '8$?KJJ++-O$11%,,v2FGLLN(+#) / 6 6 8)  !+++ G+ 3!)!2%(##))  :/**demeodpq""0!14(22G# 3$Nrlayoutc g}tt|D];}|r||nd|}|jtj ||||||=|Dcgc]}|| }}|rt|t|k(sJ|Scc}w)Ndim_)rr3appendrr) rrr[r\dim_group_namesdimrndim_non_none_group_namess rrzDeviceMesh._init_process_groupss79OS[) 2@>#.SEl&&66s Xx9I#9N 4C'Taam'T $'T/37O3PTWU4 , + (Us B!Bc6|jr |jS|Sr)rYr.s rr=zDeviceMesh._get_root_meshs&*oo4?? ?4 ?rcDtjj||Sr)rPr-rr.s r __enter__zDeviceMesh.__enter__s  & & - -d 3Krc@tjjyr)rPr-pop)r/exc_type exc_value exc_tracebacks r__exit__zDeviceMesh.__exit__s  & & * * ,rc|jrDddjdt|j|jjDdn|jj}d|d|j d|jj }tjjdd d k(r |d |jjz }|dS) N(z, c30K|]\}}|d|yw)=Nr).0kvs r z&DeviceMesh.__repr__..smTQ1QCjms)z DeviceMesh(z, 'z ', stride=TORCH_DISTRIBUTED_DEBUGDETAILz, Mesh: ) rWjoinziprXtop_level_sizesr?stridesrrgetr_r)r/device_mesh_reprs r__repr__zDeviceMesh.__repr__s''DIImS9M9Mt||OkOk5lmmnnop 445  "--=,>c$BRBRASS]^b^j^j^r^r]st zz~~7<H htyy/?/?/A.B$CC &'q) )rct|dd|_|jsGt|j|j|j |j |jf|_|jS)N_hash)rRrhashrrXrUrWrr.s r__hash__zDeviceMesh.__hash__ s_ w5DJ::!.. )),,  :: rotherc8||uryt|tsy|j|jk(xrj|j|jk(xrO|j|jk(xr4|j |j k(xr|j |j k(S)NTF)rprrrXrUrWr)r/rs r__eq__zDeviceMesh.__eq__su}eZ0&&%*A*AA8LLEMM18%%););;8((E,A,AA8OOu'7'77  rcB|js tdt|tr|fn|}||jk(r|S|j |}t j jj5|j||}ddd|S#1swYSxYw)a[ Slice the current DeviceMesh based on the mesh_dim_names given to create a submesh. The submesh created consists of the dimensions and the communicators indicated by ``mesh_dim_names`` Args: mesh_dim_names (Union[str, tuple[str, ...]]): the name or the tuple of names of the mesh dimension of the DeviceMesh to create the submesh for. Returns: A :class:`DeviceMesh` object The following program runs on each process/rank in an SPMD manner in a world size of 8. In the first example: Calling mesh_2d["tp"] on rank 0, 1, 2, 3 returns a 1D submesh of DeviceMesh:([0, 1, 2, 3]). Calling mesh_2d["tp"] on rank 4, 5, 6, 7 returns a 1D submesh of DeviceMesh:([4, 5, 6, 7]). Calling mesh_2d["dp"] on rank 0, 4 returns a 1D submesh of DeviceMesh:([0, 4]). Calling mesh_2d["dp"] on rank 1, 5 returns a 1D submesh of DeviceMesh:([1, 5]). Calling mesh_2d["dp"] on rank 2, 6 returns a 1D submesh of DeviceMesh:([2, 6]). Calling mesh_2d["dp"] on rank 3, 7 returns a 1D submesh of DeviceMesh:([3, 7]). In the second example: Calling mesh_3d["dp", "cp"] on rank 0, 1, 4, 5 returns a 2D submesh of DeviceMesh:([[0, 1], [4, 5]]). Calling mesh_3d["dp", "cp"] on rank 2, 3, 6, 7 returns a 2D submesh of DeviceMesh:([[2, 3], [6, 7]]). Calling mesh_3d["cp", "dp"] on rank 0, 1, 4, 5 returns a 2D submesh of DeviceMesh:([[0, 4], [1, 5]]). Calling mesh_3d["cp", "dp"] on rank 2, 3, 6, 7 returns a 2D submesh of DeviceMesh:([[2, 6], [3, 7]]). Example:: >>> # xdoctest: +SKIP("no rank") >>> from torch.distributed.device_mesh import DeviceMesh >>> >>> # Initialize a 2D device mesh as (2, 4) to represent the topology >>> # of cross-host(dim 0), and within-host (dim 1). >>> mesh_2d = init_device_mesh(device_type="cuda", (2,4), mesh_dim_names=("dp", "tp")) >>> tp_mesh = mesh_2d["tp"] >>> dp_mesh = mesh_2d["dp"] >>> >>> # Initialize a 3D mesh. >>> mesh_3d = init_device_mesh(device_type="cuda", (2,2,2), mesh_dim_names=("dp", "pp", "cp")) >>> # The order of the mesh_dim_names provided deteremines the order of dimensions in the submesh. >>> dp_cp_mesh = mesh_3d["dp", "cp"] >>> cp_dp_mesh = mesh_3d["cp", "dp"] z1Cannot slice a DeviceMesh without mesh_dim_names!N) rWr4rprM_get_slice_mesh_layoutrS _subclasses fake_tensorunset_fake_temporarily_create_sub_mesh)r/r[sliced_mesh_layoutsubmeshs r __getitem__zDeviceMesh.__getitem__%sX''"#VWW&0%D!. !5!55 %)%@%@%P"&&22IIKX"334FWGXXs 7BBmesh_dimct|ds tdt|jdkDr&|$tdt|jdddt|jdk(r#|!t t |j dS|j}|j}|r*||vr&||j d}t t |St|tr|j|n|}t|tstd t|t t |j |S) a Returns the single ProcessGroup specified by mesh_dim, or, if mesh_dim is not specified and the DeviceMesh is 1-dimensional, returns the only ProcessGroup in the mesh. Args: mesh_dim (str/int, optional): it can be the name of the mesh dimension or the index of the mesh dimension. Default is None. Returns: A :class:`ProcessGroup` object. rz*DeviceMesh process groups not initialized!rfFound the DeviceMesh have dimensionsJOptional kwarg `mesh_dim` needs to be specified when device_mesh.ndim > 1.zmIf you want to get the list of all the ProcessGroups in the DeviceMesh,please use `get_all_groups()` instead.rzmesh_dim must be an int, got )hasattrr4r3rXr rrr=rZrprM_get_mesh_dim_by_namerNrrr)r/r root_meshroot_to_flatten_mappingdim_group_names r get_groupzDeviceMesh.get_groupisL4!34"#OPP4<< 1$)9"0T\\1B0C;O`=4<< A%(*: 6t7L7LQ7O PQQ++-I&/&@&@ #&87N+N!8"""1"& 6~ FGG"(C0..x8! "(C0(7X7GH 6t7L7LX7V WXXrctt|jDcgc]}|j|c}Scc}w)z Returns a list of ProcessGroups for all mesh dimensions. Returns: A list of :class:`ProcessGroup` object. )rr3rXr)r/is rget_all_groupszDeviceMesh.get_all_groupss/05S5F/GH!DNN1%H HHs<submesh_dim_namesc|j}g}|D]}|t|jvrA|j|jt|jj |[|j |}|j|jt|jj |t|j||j||d}||_|S)NFrXrVr[rYr]) r=r rWrrindexrZrrUrV)r/rrrslice_dim_group_namer flatten_mesh res_submeshs rrzDeviceMesh._create_sub_meshs ++-I#% ) 8D$8$899(//--$T%9%9:@@F$(#8#8#>L(//$55$\%A%ABHHN "%!!#--0$# K,@K ( rrhrGc|j}|s$djt|j}|jdk(r|t|jvr|St|j}||vrt |d|dd|d|j j}t|dkDr|j}||jvr:||j|j k(r|j|St d|dt|j||j|f||f }||j|<|S) N_rfz# already exists for submesh of the . z5The mesh_dim_names of submesh and flattened mesh are z-. Please specify another valid mesh_dim_name.z Flatten mesh with mesh_dim_name zE has been created before, Please specify another valid mesh_dim_name.)rXrVr[rYr\)r=rr rWr|rsrXcoalescer3rrZrrUrV)r/rGr\rinvalid_dim_namesflattened_mesh_layoutres_flattened_meshs r_create_flatten_meshzDeviceMesh._create_flatten_meshs~ ++-I #$2F2F)G H yyA~-8D.+s!!55szInvalid mesh_dim_names z% specified. Valid mesh_dim_names are rjzzSlicing a flattened dim from root mesh will be deprecated in PT 2.11. Users need to bookkeep the flattened mesh directly. r8r9c34K|]}|jywr)sizesrls rrz4DeviceMesh._get_slice_mesh_layout..Bs @Q @c34K|]}|jywr)rrs rrz4DeviceMesh._get_slice_mesh_layout..Cs"D199"Drr2zCCurrently, this only allows slicing out a contiguous flattened dim.z: specified. Mesh dim indices should be in ascending order.zSlicing overlapping dim_names z is not allowed.)r=rZitemsrXr rWallrrrr;r<rreversedr NotImplementedErrorr r{r4) r/r[slice_from_rootkeyr_flatten_name_to_root_layout layout_slicedr sliced_sizessliced_strides pre_strideryrs @rrz!DeviceMesh._get_slice_mesh_layouts-#Ot**,,"'#&*%8%8%:%K%K%Q%Q%S!T%  ($$../$,$ %3-n-=>00D/EQH M& L8D$8$899!(( Xd.B.B%C%I%I$%OP88MMO#$ "(()DT)JK L! @- @@L""Dm"DDNJ">2 $f~-]J&"1.1ABII$  $$( nEM 224"4^4DDTU! IsGc:|j|}|j|}|j|j}|j }g}|D]H}t |j ||fd}||vr|j|gng|_|j|J|S)z` Return all the submeshes of a given mesh dimension of the device mesh. Fr[r]) rrXrrVr rrUrr) r/rGrrrcur_rank res_submeshesmesh_1drs rrIzDeviceMesh._get_all_submeshesfs11-@H\\(+F$44T^^DO}}HM* .$%%$1#3"'  7***845( $$W- .! r)r[groupct|trt|}t|tjr|j |k7s!|9t|tjs||k7rt dt|d|tj|dtj}t|||d}|jg|_ |St|}t|dk(r t d| t d | t d t|tjr/|jj!tjd n%tj|dtj}|j"t|k7r)t d |j d t|dt|||d}|Dcgc]}|jc}|_ |Scc}w)ak Constructs a :class:`DeviceMesh` with ``device_type`` from an existing :class:`ProcessGroup` or a list of existing :class:`ProcessGroup`. The constructed device mesh has number of dimensions equal to the number of groups passed. For example, if a single process group is passed in, the resulted DeviceMesh is a 1D mesh. If a list of 2 process groups is passed in, the resulted DeviceMesh is a 2D mesh. If more than one group is passed, then the ``mesh`` and ``mesh_dim_names`` arguments are required. The order of the process groups passed in determines the topology of the mesh. For example, the first process group will be the 0th dimension of the DeviceMesh. The `mesh` tensor passed in must have the same number of dimensions as the number of process groups passed in, and the order of the dimensions in the `mesh` tensor must match the order in the process groups passed in. Args: group (ProcessGroup or list[ProcessGroup]): the existing ProcessGroup or a list of existing ProcessGroups. device_type (str): The device type of the mesh. Currently supports: "cpu", "cuda/cuda-like". Passing in a device type with a GPU index, such as "cuda:0", is not allowed. mesh (torch.Tensor or ArrayLike, optional): A multi-dimensional array or an integer tensor describing the layout of devices, where the IDs are global IDs of the default process group. Default is None. mesh_dim_names (tuple[str, ...], optional): A tuple of mesh dimension names to assign to each dimension of the multi-dimensional array describing the layout of devices. Its length must match the length of `mesh_shape`. Each string in `mesh_dim_names` must be unique. Default is None. Returns: DeviceMesh: A :class:`DeviceMesh` object representing the device layout. z Invalid mesh z for ProcessGroup with ranks rardFr*rz.Expects at least one ProcessGroup to be passedz0Must pass mesh if passing multiple ProcessGroupsz:Must pass mesh_dim_names if passing multiple ProcessGroups)rcrezEExpects mesh with ndim equal to number of ProcessGroups but got mesh riz ProcessGroups)rpr&rrSrqrrsrMrwrNrrrrOr3rtrur|)r.r?r_r[ group_ranksr6groupss r from_groupzDeviceMesh.from_groupsV%.5e< tU\\2t{{} 7S$&tU\\: +$'D {2OP[}]||KUYYO(#1"'  160@0@/A ,""%[F6{a !QRR| !STT% PdELL1   uyy ?\\$uEIIF  yyCK'  KKM?%F }NL%T.PUKKQ+QE,<,<+QK ( ,RsG+ct||j|jS|jjSr)rXr~)r/rs rrxzDeviceMesh.sizes3#||H-3355<<%%' 'rc,t|jSr)r3rXr.s rr|zDeviceMesh.ndimst||$ $rc.|jjSr)rXrr.s rshapezDeviceMesh.shapes<<// /rctS)z: Returns the current global rank. )r r.s rr zDeviceMesh.get_ranks : rc|jdkDr%|#tdt|jdd|d}t |j |}t |ts tdt t|S)a| Returns the local rank of the given mesh_dim of the DeviceMesh. Args: mesh_dim (str/int, optional): it can be the name of the mesh dimension or the index of the mesh dimension. Default is None. Returns: An integer denotes the local rank. The following program runs on each process/rank in an SPMD manner. In this example, we have 2 hosts with 4 GPUs each. Calling mesh_2d.get_local_rank(mesh_dim=0) on rank 0, 1, 2, 3 would return 0. Calling mesh_2d.get_local_rank(mesh_dim=0) on rank 4, 5, 6, 7 would return 1. Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 0, 4 would return 0. Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 1, 5 would return 1. Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 2, 6 would return 2. Calling mesh_2d.get_local_rank(mesh_dim=1) on rank 3, 7 would return 3. Example:: >>> # xdoctest: +SKIP("no rank") >>> from torch.distributed.device_mesh import DeviceMesh >>> >>> # Initialize device mesh as (2, 4) to represent the topology >>> # of cross-host(dim 0), and within-host (dim 1). >>> mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1, 2, 3],[4, 5, 6, 7]]) rfrrrrz1We expect ProcessGroup before calling `get_rank`!) r|r4r3rXr rrpr&rr )r/rmesh_dim_groups rget_local_rankzDeviceMesh.get_local_ranks:yy1}!1"0T\\1B0C;O`!%dnnX&>?Nnl;$GH^45 5rc6|jr |jSdS)z Return the relative indices of this rank relative to all dimensions of the mesh. If this rank is not part of the mesh, return None. N)rr.s rget_coordinatezDeviceMesh.get_coordinates /3.E.E4** O4 Orc~|js td|td|id\}nd}|j||S)a\ Returns a 1D DeviceMesh by flattening the current DeviceMesh. If no mesh_dim_name is provided, the default is a string concatenating the mesh_dim_names of the given submesh with each mesh_dim_name separated by "_". For example, if we have a 3D mesh DeviceMesh([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], mesh_dim_names=("dp", "cp", "tp")), calling mesh_3d["dp", "cp"]._flatten() will create a 1D submesh DeviceMesh([0, 2, 4, 6], mesh_dim_names=("dp_cp",)) on rank 0, 2, 4, 6 and a 1D submesh DeviceMesh([1, 3, 5, 7], mesh_dim_names=("dp_cp",)) on rank 1, 3, 5, 7. After the flattened dimension is created, to access the flattened dimension in mesh_3d, one can use the existing slicing method to obtain the flattened mesh through calling mesh_3d["dp_cp"]. z3Cannot flatten a DeviceMesh without mesh_dim_names!rrfrh)rWr4_normalize_backend_overrider)r/rGr\backend_override_tuples r_flattenzDeviceMesh._flatten$sZ(''"I +,G()1-)'*6&,,]'>'@@ 1j]$|7I7I7K6LM99<Z UXHYH_H_HaGbcKL "\\#.::<HN!%!4!4S#'>!R )-ht7J7J.K)L &8<^8L &sS1W 5++-I!  *#--$%?@$# Ht/0"&"7"7"<"<">151J1J"''"$ 2cAg. -<)Orc.t|tr*||jk\rtd|d|jt|tr2|t |j vrtd|d|j t|t|k7r tdt|tr$t |j j|}| tt|t||}ndt|z}|j||||S)aL Returns a DeviceMesh by unflatten the current DeviceMesh. This api can be used to unflatten a N-D DeviceMesh into N-1+len(mesh_sizes)-D meshes or submeshes. The dim is the dimension to be unflattened which can be either a string or an integer. The mesh_sizes is a tuple which specifies the shape of the mesh unflatten into for the given dim. The mesh_dim_names is a list of strings which specifies the names of the dimensions of the mesh unflatten into. Its length must match the length of mesh_sizes. For example, if we have a 1D mesh DeviceMesh([0, 1, 2, 3, 4, 5, 6, 7], mesh_dim_names=("world")), calling mesh_1d._unflatten(0, (2, 2, 4), ["dp", "pp", "tp"]) will create a 3D mesh DeviceMesh([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], mesh_dim_names=("dp", "cp", "tp")). Note that after calling the unflatten, there is no access to the unflattened dimension in mesh_1d, one can only use the newly unflattened mesh to slice out the unflattened mesh dims. zdim z+ specified in `_unflatten` is out of range z% specified in `_unflatten` is not in zAmesh_dim_names must have same length as mesh_sizes in _unflatten!rg) rprNr|rsrMr r[r3r4rrr>rK)r/rrAr[r\r?s r _unflattenzDeviceMesh._unflattenws6#s#tyy(8 3%J499+VC%#$:M:M1N*N 3%DTEXEXDYZ:#n"55"W#s#t22399#>+)./(J&*&*93~;N)N&..&  rdevice_mesh_listcg}g}g}g}|dj}|D]}tt|jD]R}|j |j|j |j |j|j T|jt|j|jt|j|j|k7stdtt|t|}|jstd|t|dj ||dj"t||dj%d} || _ | S)NrzCCannot concatenate DeviceMeshes derived from different device meshsz'Cannot concatenate overlapping meshes: Fr)rrr3rXrrrextendr r[rr4r rr{rr?rVr=) rNconcat_dim_names concat_sizesconcat_stridesconcat_dim_group_nameflatten_rank_mapdmrconcat_mesh_layoutrJs r _concatenatezDeviceMesh._concatenatesx*, +-L-/N57 !/2DD & s2::/AA '' 1 (;(;<"))"**Q-*?*?@A!''1B1B(CD%,,Xb6I6I-JK''+;;&] "-U<-@%BW!X %779"=>N=OP" #//**1-77$%56+A.==?# H)>H %OrrrKrJ)Nrh)rg):rrr__doc__rM__annotations__rSrqrr rYrdictr BackendConfigboolrNr0propertyr?r_r[rrLr"rrOrr=rrrrobjectrrr&rrrrrrrrIr2rxr|r6r r:r< C10dBackendOptionsr@rKrMrXrrrrrs(- ^<<sCx4//-1 H\*1sL011 =Aq  6:AE"& $*.-115q q  k12T9q  "#s(Od2 q  $M3$67$> q  q :q !4'q ||d*q !.q q f  % %  %  %,,     (E#s(Od$: (  (1 (f \ #\ ll\ \ , \    \  \ |  , ,ll ,"#s(Od2 ,$M3$67  , )_  ,  ,0 @   - *c *   4 B cE#s(O.CB  B H, YcCi$&6, Y,, Y\ ID$6 I! !  %S#X!  ! J)-.:1 &:1 &,1 & 1 &f d  Gs Gs GR !"'S/R ! R !j !C !Dr>s  !N!,U4[.!I  GX#4D(D..&4WI> (z)=?'**84,,&**73""#s#Dk!C!4!45Sk! ' * >tDTDYDYD[?\>]^226|NCSU  sCC)r[r\ mesh_shapec |ktt|t|k7rtdd|t|t|k7r%tddt|dt|d| tt |t||}nd}|r |j std|d d t t|tt|}tjd 5tj|jtj }dddt|||| }|S#1swYxYw)a Initializes a `DeviceMesh` based on `device_type`, `mesh_shape`, and `mesh_dim_names` parameters. This creates a DeviceMesh with an n-dimensional array layout, where `n` is the length of `mesh_shape`. If `mesh_dim_names` is provided, each dimension is labeled as `mesh_dim_names[i]`. .. note:: `init_device_mesh` follows SPMD programming model, meaning the same PyTorch Python program runs on all processes/ranks in the cluster. Ensure `mesh_shape` (the dimensions of the nD array describing device layout) is identical across all ranks. Inconsistent `mesh_shape` may lead to hanging. .. note:: If no process group is found, init_device_mesh will initialize distributed process group/groups required for distributed communications behind the scene. Args: device_type (str): The device type of the mesh. Currently supports: "cpu", "cuda/cuda-like", "xpu". Passing in a device type with a GPU index, such as "cuda:0", is not allowed. mesh_shape (Tuple[int]): A tuple defining the dimensions of the multi-dimensional array describing the layout of devices. mesh_dim_names (tuple[str, ...], optional): A tuple of mesh dimension names to assign to each dimension of the multi-dimensional array describing the layout of devices. Its length must match the length of `mesh_shape`. Each string in `mesh_dim_names` must be unique. backend_override (Dict[int | str, tuple[str, Options] | str | Options], optional): Overrides for some or all of the ProcessGroups that will be created for each mesh dimension. Each key can be either the index of a dimension or its name (if mesh_dim_names is provided). Each value can be a tuple containing the name of the backend and its options, or just one of these two components (in which case the other will be set to its default value). Returns: DeviceMesh: A :class:`DeviceMesh` object representing the device layout. Example:: >>> # xdoctest: +SKIP("no rank") >>> from torch.distributed.device_mesh import init_device_mesh >>> >>> mesh_1d = init_device_mesh("cuda", mesh_shape=(8,)) >>> mesh_2d = init_device_mesh("cuda", mesh_shape=(2, 8), mesh_dim_names=("dp", "tp")) Nz"Each mesh_dim_name must be unique.z/Found repeated mesh_dim_name in mesh_dim_names z6mesh_shape and mesh_dim_names should have same length!zFound len(mesh_dim_names): z and len(mesh_shape):rjz0Device type with index is not supported but got r zUIf you maintained a 'torch.device' object, it's recommended to pass in 'device.type'.rarb)r?rXrVr[r\)r3setr4rr>isalphar r rSrearanger~rNr)r?rfr[r\r?rrr6s rrrs[f  %3~&'3~+>>"8EnEUV :#n"55"L1#n2E1FF[\_`j\k[llmn  '%*+$c*o~& " &* " {224B;-rRg  U:.uZ?P0QR\\%  E||FLLN%))DH E #)3   E Es 04D>>E)rr)Cloggingrrr;collections.abcr itertoolsrtypingrrrrStorch.distributedrtorch.distributed._mesh_layoutr torch.distributed._pycuter r r torch.utils._typing_utilsr __all__sysrrmodulesrrtorch._C._distributed_c10drr`"torch.distributed.distributed_c10drrrrr r!r"r#r$r%r&r' getLoggerrr numpy.typingr( ImportErrorwarningrrMrar\ serializationadd_safe_globalslocalr*rPrZrAr[rNr>rrrrs[ $!11 *6FF. | ,~   ?NCKK/0;0KK'B    W  x (F  . #*k&9&9D&@@AM ((+7,A9??,A\!) OX*11UUz"26 # #I +%% %c;3F3F.F(G G I #  # c3h$. # - #R26]]#s(O]c3h$. ]  #Is[0005k>Q>Q9Q3RR R   ] ]{%  NNU  sF99GG