U 9%eH@s UddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddlm Z ddl m Z ddlmZmZmZmZmZmZmZddlZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*ddl+m,Z,m-Z-dd l.m/Z/m.Z.d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQgHZ0dRZ1dRZ2dRZ3dRZ4ej5Z6ej7Z8dSdTZ9e9z ddUlm:Z:dVe:_;e0dWg7Z0WneZ>dd\lm?Z?dVe>_;e0d]g7Z0Wnesz*BackendConfig.__init__..:z/The custom backend string argument is invalid: z. Custom backend string is an experimental feature where the backend string must be in the format: ":,:...". e.g. 'cpu:gloo,cuda:nccl',zEInvalid device:backend pairing: z. zDuplicate device type z9 in backend string: rzp unknown, assuming `cpu` and `cuda`. You can specify it in `device:backend` format in `init_process_group` call.)rnroZxpuzUsing backend config: )device_backend_mapr"ryrprArzrrqsplitlenrvrrloggerinfo)selfrrZsupported_devicesZbackend_str_error_messageZdevice_backend_pair_strZdevice_backend_pairr\rr]__init__ sP           zBackendConfig.__init__cCsddd|jDS)Nrcss |]\}}|d|VqdS)rNr\)rrrr\r\r] Gsz)BackendConfig.__repr__..)joinritemsrr\r\r]__repr__EszBackendConfig.__repr__cCs|jSrf)rrr\r\r]get_device_backend_mapIsz$BackendConfig.get_device_backend_mapN) rrZrr rur"rrrr\r\r\r]r# s9c@s eZdZdZddZddZdS) _reduce_opz Deprecated enum-like class for reduction operations: ``SUM``, ``PRODUCT``, ``MIN``, and ``MAX``. :class:`~torch.distributed.ReduceOp` is recommended to use instead. cCs0tjjD]\}}t|||q tjj|_dSrf)rZ RedOpType __members__rr)rkvr\r\r]rTsz_reduce_op.__init__cCstdt||S)NzXtorch.distributed.reduce_op is deprecated, please use torch.distributed.ReduceOp instead)rrobject__getattribute__)rkeyr\r\r]rZsz_reduce_op.__getattribute__N)rrZrrrrr\r\r\r]rLsrc@sLeZdZdZd eejeee edddZ d eejeee edddZ dS) r%a A class to build point-to-point operations for ``batch_isend_irecv``. This class builds the type of P2P operation, communication buffer, peer rank, Process Group, and tag. Instances of this class will be passed to ``batch_isend_irecv`` for point-to-point communications. Args: op (Callable): A function to send data to or receive data from a peer process. The type of ``op`` is either ``torch.distributed.isend`` or ``torch.distributed.irecv``. tensor (Tensor): Tensor to send or receive. peer (int): Destination or source rank. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. tag (int, optional): Tag to match send with recv. Nroptensorpeerr;tagcCs"||_||_||_||_||_dSrfr)rrrrr;rr\r\r]rxs zP2POp.__init__cCst|t|dt|S)Nr) _check_op_check_single_tensorrr})r{rrrr;rr\r\r]r}s z P2POp.__new__)Nr)Nr) rrZrrrtorchTensorintrrrr}r\r\r\r]r%es  c@s8eZdZdZdeejeejeeee dddZ dS)_CollOpa A class to capture collective operations. Args: op (Callable): A collective function, e.g. ``torch.distributed.all_reduce``. tensor (Tensor): Tensor to operate on. dst_tensor (Tensor, optional): Provided when source and destinaton tensors are not the same. redop (ReduceOp, optional): reduce operation. root (int, optional): root of broadcast or reduce. Nrr dst_tensorredoprootcCs"||_||_||_||_||_dSrfr)rrrrrrr\r\r]rs z_CollOp.__init__)NNN) rrZrrrrrrrrrr\r\r\r]rs r_pg_map _pg_names_pg_group_ranks_pg_backend_config _tags_to_pg _pg_to_tagc@sneZdZdZddZeddZejddZeee e e e e ffddd Zeee e fdd d Zeee eeeffdd d Zeee e fdddZeedddZejddZeee ee fdddZeee e fdddZeee eeeeffdddZeee ejfdddZeeee eee ffdddZdS)_Worldz Container class for c10d process group state. This is used during registration and lookup of PG state. .. warning:: This is an experimental API intended to expose the inner workings of c10d and is subject to change.. cCsd|_i|_i|_dSrf) _default_pg_pg_coalesce_state_pg_default_devicerr\r\r]rsz_World.__init__cCs|jS)z The default ProcessGroup includes all ranks of the cluster. This is used by c10d APIs when a ProcessGroup is needed but None is provided. rrr\r\r] default_pgsz_World.default_pgcCs ||_dSrfrrr|r\r\r]rsrecCstS)z Cached process groups For NCCL and GLOO pg, it is a map from ProcessGroup to (Backend, Store) For MPI pg, it is a map from ProcessGroup to (Backend, None) TODO don't expose the map, expose fine grained ops )rrr\r\r]pg_maps z _World.pg_mapcCstS)z Process group's names, map from ProcessGroup to str. TODO don't expose the map, expose fine grained ops )rrr\r\r]pg_namessz_World.pg_namescCstS)z~ Process group's global rank to local rank mapping TODO don't expose the map, expose fine grained ops )rrr\r\r]pg_group_rankssz_World.pg_group_rankscCstS)zk Process group's backend config TODO don't expose the map, expose fine grained ops )rrr\r\r]pg_backend_configsz_World.pg_backend_configcCstS)z| Process group count for default naming. TODO don't expose group_count, use something else instead  _group_countrr\r\r] group_countsz_World.group_countcCs|adS)zk Count is used when computing the name of ProcessGroups when using global synchronization. Nrrr\r\r]rscCstSrf)rrr\r\r] tags_to_pgsz_World.tags_to_pgcCstSrf)rrr\r\r] pg_to_tagsz_World.pg_to_tagcCs|jSrf)rrr\r\r]pg_coalesce_statesz_World.pg_coalesce_statecCs|jSrf)rrr\r\r]pg_default_device sz_World.pg_default_devicecCsTg}|jD]@\}}tj|d}|||||j||j|dq|S)z Returns a list of dict with process groups and backends with their unique IDs and configurations (types and ranks). r)Zpg_idZ backend_idbackend_configranks) rrr"rrrZ_idZ _backend_idrr)rZ config_infopgr backend_typer\r\r]pg_config_info sz_World.pg_config_infoN)rrZrrrpropertyrsetterrrrrurrrrrrrrr rrr rr%rrrrrr\r\r\r]rs8  $     $rc@s>eZdZdZeeedddZejeedddZdS) _WorldMetazh Meta class of ``group`` and ``GroupMember`` so they can have the class property ``WORLD``. rcCstjSrf_worldr)r{r\r\r]WORLD+sz_WorldMeta.WORLDrcCs |t_dSrfr)r{rr\r\r]r/sN) rrZrrrrrrrr\r\r\r]r%s rc@s eZdZdS)r;N)rrZrr\r\r\r]r;3s) metaclassc@seZdZdZdS)r$iN)rrZrNON_GROUP_MEMBERr\r\r\r]r$6sZstore_based_barrier_keyr;cCs|pt}|tjkrtj|St|tsXtdt|dt dtj|<tj|S|j }t |dkrz|dtj|<nLt |dkrt dtj|<n.t d|krt dtj|<n|dtj|<t dtj|dtj|S)a Returns the device to use with ``group`` for control flow usage (object collectives, barrier). There are selection rules: 1. If user specifies exactly one backend in ``init_process_group`` call: use that backend 2. Else if user specifies multiple "device:backend" pairs in init_process_group: If "cpu" is among those pairs, use "cpu" (because the object is in cpu memory); Otherwise, use the first backend (sort of a random pick). Args: group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Returns: torch.device: The device to use with ``group``. zYou are using a Backend zw as a ProcessGroup. This usage is deprecated since PyTorch 2.0. Please use a public API of PyTorch Distributed instead.rnrrz Using device z for object collectives.)_get_default_grouprrrtrrrr[rrZ _device_typesrrr)r;r~r\r\r]_get_pg_default_device?s*       r secondsc Cstd|}||dtd|||}||d}|d} ||krV|| dt} z|| g|WqWq^tk r} zP||d}td|||||tt| d|krtd |||||W5d } ~ XYq^Xq^td |||d S) z Barrier based on store which is used for synchronizing processes after ``init_process_group`` or ``new_group``. Intended to be used only with those two methods and is not a generic alternative to ``barrier()``. rrz#Added key: %s to store for rank: %srz :last_worker1zWaiting in store based barrier to initialize process group for rank: %s, key: %s (world_size=%s, num_workers_joined=%s, timeout=%s)rzTimed out initializing process group in store based barrier on rank {}, for key: {} (world_size={}, num_workers_joined={}, timeout={})Nz@Rank %s: Completed store-based barrier for key:%s with %s nodes.) STORE_BASED_BARRIER_PREFIXaddrrsettimewait RuntimeErrorrformat) rankstore group_nameZrendezvous_counttimeoutZlogging_intervalZ store_key world_sizeZ worker_countZlast_worker_keystarter\r\r]_store_based_barriersL     rcCs|dkr dS|tjkS)zS Helper that checks if the current process's rank is not in a given group. NF)r$rrr\r\r]_rank_not_in_groupsrcCs4tjdkrdntj}td|d|ddS)NzRunning z on global rank z* which does not belong to the given group.)r$rrrr)Zop_name global_rankr\r\r]_warn_not_in_groupsr)r;rrecCsV|tjkr|S|tjkr(td|dtj|}||krNtd|d|||S)a Translate a global rank into a group rank. ``global_rank`` must be part of ``group`` otherwise this raises RuntimeError. Args: group (ProcessGroup): ProcessGroup to find the relative rank. global_rank (int): Global rank to query. Returns: Group rank of ``global_rank`` relative to ``group`` N.B. calling this function on the default process group returns identity Group L is not registered, please create group with torch.distributed.new_group APIz Global rank  is not part of group )r$rrrr)r;r group_ranksr\r\r]rSs   )r; group_rankrecCsh|tjkr|S|tjkr(td|dtj|D]\}}||kr6|Sq6td|d|dS)a Translate a group rank into a global rank. ``group_rank`` must be part of `group` otherwise this raises RuntimeError. Args: group (ProcessGroup): ProcessGroup to find the global rank from. group_rank (int): Group rank to query. Returns: Global rank of ``group_rank`` relative to ``group`` N.B. calling this function on the default process group returns identity rrz Group rank rN)r$rrrrr)r;rrZgrp_rankr\r\r]rTs   cCstdt||S)z@ This method is deprecated, please use get_global_rank. ztorch.distributed.distributed_c10d._get_global_rank is deprecated please use torch.distributed.distributed_c10d.get_global_rank instead)rrrT)r;rr\r\r]_get_global_ranksrcCsttj|S)z Get all ranks associated with ``group``. Args: group (ProcessGroup): ProcessGroup to get all ranks from. Returns: List of global ranks ordered by group rank. )listrrkeysrr\r\r]rUs cCs(|tjks|dkr t}|S|S)z6 Helper that gets a given group's world size. N)r$rrsizer;rr\r\r]_get_group_size sr cCs t|tjstd|ddS)zO Helper to check that the parameter ``param_name`` is a single tensor. /Invalid function argument. Expected parameter `z` to be of type torch.Tensor.N)rtrrrparam param_namer\r\r]rs  rcCs0t|trtdd|Ds,td|ddS)zQ Helper to check that the parameter ``param_name`` is a list of tensors. css|]}t|tjVqdSrf)rtrr)rpr\r\r]r$sz%_check_tensor_list..r z#` to be of type List[torch.Tensor].N)rtrallrr r\r\r]_check_tensor_list s  rrcCst|tr|S|fSrf)rtr)objr\r\r] _as_iterable+srcGsld}tjtt|D]R}|j}|jr:|tjkr4tjntj }|dkrH|}q||krt d|d|jqdS)Nz4Invalid usage of tensors with different dtypesFound z and ) itertoolschainmaprdtype is_complexrZ complex64Zfloat32Z complex128r)tensorsZ last_dtyperZ tensor_dtyper\r\r]_ensure_all_tensors_same_dtype.srcCs|ttfkrtddS)zC Helper to check that the ``op`` is either isend or irecv. ziInvalid ``op``. Expected ``op`` to be of type ``torch.distributed.isend`` or ``torch.distributed.irecv``.N)rEr=r)rr\r\r]r@s rcsPt|trtdd|Ds$td|djtfdd|DsLtddS)zs Helper to check that the ``p2p_op_list`` is a list of P2POp instances and all ops use the same group. css|]}t|tVqdSrf)rtr%rp2p_opr\r\r]rQsz%_check_p2p_op_list..zZInvalid ``p2p_op_list``. Each op is expected to to be of type ``torch.distributed.P2POp``.rc3s|]}|jkVqdSrfrrrr\r]rZsz#All ops need to use the same group.N)rtrrrr;) p2p_op_listr\rr]_check_p2p_op_listLs rcCstS)z1 Checks if the MPI backend is available. )_MPI_AVAILABLEr\r\r\r]r@^scCstS)z2 Checks if the NCCL backend is available. )_NCCL_AVAILABLEr\r\r\r]rBescCstS)z2 Checks if the Gloo backend is available. )_GLOO_AVAILABLEr\r\r\r]r>lscCstS)z1 Checks if the UCC backend is available. )_UCC_AVAILABLEr\r\r\r]rDss)rrecCs2ttjd|dd}|r$|S|tjkS)a% Checks if the given backend is available and supports the built-in backends or third-party backends through function ``Backend.register_backend``. Args: backend (str): Backend name. Returns: bool: Returns true if the backend is available otherwise false. is_Z _availableN)rwr distributedrzr"r)rZavailable_funcr\r\r]rAzs cCs tjdk S)zD Checking if the default process group has been initialized N)r$rr\r\r\r]r?scCstddk S)a Checks whether this process was launched with ``torch.distributed.elastic`` (aka torchelastic). The existence of ``TORCHELASTIC_RUN_ID`` environment variable is used as a proxy to determine whether the current process was launched with torchelastic. This is a reasonable proxy since ``TORCHELASTIC_RUN_ID`` maps to the rendezvous id which is always a non-null value indicating the job id for peer discovery purposes.. ZTORCHELASTIC_RUN_IDN)osgetenvr\r\r\r]rCs cCsttddS)NZTORCH_DIST_INIT_BARRIER0)rr&r'r\r\r\r]_is_barrier_after_initsr)cCststdtjS)zI Getting the default process group created by init_process_group \Default process group has not been initialized, please make sure to call init_process_group.)r?rr$rr\r\r\r]rs rcCs&tstdt}tj|\}}|S)zA Getting the default store created by init_process_group r*)r?rrrr)r_ default_storer\r\r]_get_default_storesr-cCs |t_dSrfrrr\r\r]_update_default_pgsr.)r;recCsD|dkrt}n|}t|r$tdtj|}|dk s:,:", e.g. "cpu:gloo,cuda:custom_backend". :Expected timeout argument to be of type datetime.timedeltaNz5trying to initialize the default process group twice!z*Cannot specify both init_method and store.rz*world_size must be positive if using storez(rank must be non-negative if using storezenv://rhFuse_hashed_namerzFor MPI backend, world_size (z ) and rank (z9) are ignored since they are assigned by the MPI runtime.)rrrr)r4rrcSsi|] }||qSr\r\rir\r\r]rsz&init_process_group..rVPerforming barrier after ProcessGroup initialization since TORCH_DIST_INIT_BARRIER = 1)rtrrr$rrr"_process_group_namerrr_new_process_group_helperr.r!nextZ set_timeoutrranger rrrZ_backend_default_pg_init_methodr)rrr/r) rr3rrrrrr4rr+Zrendezvous_iteratorr\r\r]r<s^              c  Cs|tjkrtdt|ts(td|dkrTt||} | rTtj| \} } | | fSt|dk} | st } | |krt j dfSt |d|} tjt|d}||_t| |||}t|}|D]\}}t |d| }|tjkrTtstdt|}tjj}|st j S| d kr|d krt|| ||}nN|tjkr|t||||d }tjj}n&|tjkrtstd |dk rt|t jst!d nt }d |_"||_t ||||}tjj}n|tj#krt$rt%||||d }tjj#}n|&tj'ks6t!d|&tj'|&}|j(}|j)}tjj*}|sn|||||}n4t+}||_,||_-||_.||_/||_0||_1|||}|tjtjfkr|2t3t4|tr|}q~|tjtjtj#fkr t5t6j7kr t8s t9:dnt;||||||d}tt<|dkrh|=D]}|>t?@|||qFq~|>t?@|||q|| ftj|<|tj|<t|tjA|<|dkrd|}tjBCdgD|n d|}tjBC|gD||tjE|<|| fS)a` Create a new distributed process group. This function must be called by ALL processes in the global group, even if the calling process is not part of the newly created group. In that case, this function returns GroupMember.NON_GROUP_MEMBER. This function is called with ``global_ranks_in_group == []`` for the default group. zTThe specified group name has already been created, please use a different group namer5)Nr2rN/rzDistributed package doesn't have MPI built in. MPI is only included if you build PyTorch from source on a host that has MPI installed.rr8z.Distributed package doesn't have NCCL built inzCExpected pg_options argument to be of type ProcessGroupNCCL.OptionsFzUnknown c10d backend type aTORCH_DISTRIBUTED_DEBUG was set to DETAIL, but GLOO is not available. Build with Gloo to create a wrapper process group in debug mode to aid collective desynchronization debugging. wrapped_pg store_prefixrrrrrptd:r2user:)Frrvaluesrrtr_find_pg_by_ranks_and_tagrrrrr$rrrOptionsru_timeoutr#rrr"rr@r_createrr rrarrBr`rZis_high_priority_streamrrDrcrxrmrkrlrrrr group_sizerZgroup_idglobal_ranks_in_groupZ_set_sequence_number_for_group issubclassr[rrZDETAILr"rr_create_process_group_wrapperrrZ_register_backendrrrr setdefaultrr)rLrrMrrr4rrpg_tagZexisting_groupr+Z prefix_storeZis_default_grouprZbase_pg_optionsrrrZ backend_strZbackend_prefix_storeZ backend_classrZbackend_pluginrkrlZdist_backend_optsr\r\r]r=s                      r=cCs|tjkrdS|dkrtj}n|}|dk s.ttj|ddkrHtd| dkrh| rh| |dksz|tjkrt dtj tj tj tj tj tj tj tj dt_ntj|=tj|=tj|=tj|=|tjkrtj|=|tjkr0tdtj|=tj|}tj|=|dk rz0tj|||dr|tjd|Wntk rYnXdS)ax Destroy a given process group, and deinitialize the distributed package Args: group (ProcessGroup, optional): The process group to be destroyed, if group.WORLD is given, all process groups including the default one will be destroyed. Nr/rirzfSome coalesced collectives haven't been launched when ProcessGroup is destroyed. They will be cleaned.rEr2)r$rrrrrr0rrsrzZ _has_hooksZ_wait_for_pending_worksr.clearrrrrrrrrrrrremove startswith Exception)r;rrr\r\r]r4XsR               cCs:t|r dSt}|dks$|tjkr,|St||S)a Returns the rank of the current process in the provided ``group`` or the default group if none was provided. Rank is a unique identifier assigned to each process within a distributed process group. They are always consecutive integers ranging from 0 to ``world_size``. Args: group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Returns: The rank of the process group -1, if not part of the group rN)rrr$rrrSr r\r\r]r9s cCst|r dSt|S)a4 Returns the number of processes in the current process group Args: group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Returns: The world size of the process group -1, if not part of the group r)rr rr\r\r]r:s )rdstr;rrecCsdt|dt|rtddS|dks0|tjkrFt}||g||St||}||g||SdS)aY Sends a tensor asynchronously. .. warning:: Modifying ``tensor`` before the request completes causes undefined behavior. .. warning:: ``tag`` is not supported with the NCCL backend. Args: tensor (Tensor): Tensor to send. dst (int): Destination rank. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. tag (int, optional): Tag to match send with remote recv Returns: A distributed request object. None, if not part of the group rrEN)rrrr$rrrQrSrrVr;rrgroup_dst_rankr\r\r]rEs  )rsrcr;rrecCst|dt|rtddS|dks0|tjkr8t}n|}|dkrR||g|S|tjkrl||g||St||}||g||SdS)a? Receives a tensor asynchronously. .. warning:: ``tag`` is not supported with the NCCL backend. Args: tensor (Tensor): Tensor to fill with received data. src (int, optional): Source rank. Will receive from any process if unspecified. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. tag (int, optional): Tag to match recv with remote send Returns: A distributed request object. None, if not part of the group rr=N) rrrr$rrrecv_anysourcerJrS)rrYr;rrgroup_src_rankr\r\r]r=s   cCst|krtdt|dt|r0tddS|dksB|tjkr^t}||g|| nt ||}||g|| dS)a Sends a tensor synchronously. Args: tensor (Tensor): Tensor to send. dst (int): Destination rank. Destination rank should not be the same as the rank of the current process. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. tag (int, optional): Tag to match send with remote recv zeInvalid destination rank: destination rank should not be the same as the rank of the current process.rrQN) r9rvrrrr$rrrQrrSrWr\r\r]rQ"s   cCst|dt|rtddS|dkr.t}n|}|dkrz||g|}||}|dksj|tjkrn|St ||SnJ|dks|tjkr| |g||nt ||}| |g|||SdS)a Receives a tensor synchronously. Args: tensor (Tensor): Tensor to fill with received data. src (int, optional): Source rank. Will receive from any process if unspecified. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. tag (int, optional): Tag to match recv with remote send Returns: Sender rank -1, if not part of the group rrJrN) rrrrrZr _source_rankr$rrTrJrS)rrYr;rrworkZsrc_rankr[r\r\r]rJBs&   c@seZdZddZdS) _IllegalWorkcCs|dkrtd|ddS)N)Z is_success exceptionrZ source_rankr\resultZ synchronizezIllegal to call z on IllegalWork object)r)rrsr\r\r]rpsz_IllegalWork.__getattribute__N)rrZrrr\r\r\r]r^osr^c@s*eZdZddZedddZddZdS) _CoalescingManagercCs g|_dSrf)worksrr\r\r]rvsz_CoalescingManager.__init__)r]cCs|r|j|dSrf)rbrrr]r\r\r]rysz_CoalescingManager.appendcCs|jD] }|qdSrf)rbrrcr\r\r]r}s z_CoalescingManager.waitN)rrZrrrrrr\r\r\r]rausra)r;r async_opsc csv|pt}tj|g}|r$td|r2||t}|Vtj|}|rH|dj}|t krg}|D]}| |j qjt }|dj |_|||} n|tkrg} g} |D]}| |j | |jq|| | } nl|tkr2g} g} |D].}| |j | |jt}|dj |_q|| | |} ntd|d|d|rX||} |rj| | n| dS)a< A context manager used to coalesce collectives or P2P operations when possible. Args: group (`ProcessGroup`, optional): The process group to work on. If None, the default process group will be used. device (`torch.device`, optional): Default is None, set to a device if there isn't a `**_coalesced` implementation by the backend. async_ops (`bool`, optional): whether the coalesced ops are async ops. Examples: >>> # xdoctest: +SKIP("no rank") >>> # Synchronous ops >>> with _coalescing_manager(): >>> for i in range(num_colls): >>> dist.all_reduce(tensors[i]) >>> # Asynchronous ops >>> with _coalescing_manager(async_ops=True) as cm: >>> for i in range(num_colls): >>> dist.all_reduce(tensors[i]) >>> cm.wait() .. warning:: :func:`_coalescing_manager` currently do not support coalescing all-reduces with different reduce operators, e.g. `ReduceOp.SUM` mixed with `ReduceOp.PRODUCT`. z=ProcessGroup has non-empty op list at the start of coalescingrz>> # xdoctest: +SKIP("no rank") >>> send_tensor = torch.arange(2) + 2 * rank >>> recv_tensor = torch.randn(2) >>> send_op = dist.P2POp(dist.isend, send_tensor, (rank + 1)%world_size) >>> recv_op = dist.P2POp(dist.irecv, recv_tensor, (rank - 1 + world_size)%world_size) >>> reqs = batch_isend_irecv([send_op, recv_op]) >>> for req in reqs: >>> req.wait() >>> recv_tensor tensor([2, 3]) # Rank 0 tensor([0, 1]) # Rank 1 .. note:: Note that when this API is used with the NCCL PG backend, users must set the current GPU device with `torch.cuda.set_device`, otherwise it will lead to unexpected hang issues. In addition, if this API is the first collective call in the ``group`` passed to ``dist.P2POp``, all ranks of the ``group`` must participate in this API call; otherwise, the behavior is undefined. If this API call is not the first collective call in the ``group``, batched P2P operations involving only a subset of ranks of the ``group`` are allowed. rroT)rdN) rr;rrr[rlrrrrbr)rr;rrhrreqsr]r\r\r]r0s(   $ c Cstdt|rtddSt}||_||_|dksB|tjkrVt }| ||}nt ||}||_| ||}|rz|S| dS)aP Broadcasts the tensor to the whole group with multiple GPU tensors per node. ``tensor`` must have the same number of elements in all the GPUs from all processes participating in the collective. each tensor in the list must be on a different GPU Only nccl and gloo backend are currently supported tensors should only be GPU tensors Args: tensor_list (List[Tensor]): Tensors that participate in the collective operation. If ``src`` is the rank, then the specified ``src_tensor`` element of ``tensor_list`` (``tensor_list[src_tensor]``) will be broadcast to all other tensors (on different GPUs) in the src process and all tensors in ``tensor_list`` of other non-src processes. You also need to make sure that ``len(tensor_list)`` is the same for all the distributed processes calling this function. src (int): Source rank. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op src_tensor (int, optional): Source tensor rank within ``tensor_list`` Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group ztorch.distributed.broadcast_multigpu will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#multi-gpu-collective-functionsr2N) rrrrrrootRank rootTensorr$rrr1rSr) tensor_listrYr;async_opZ src_tensorrirr]r[r\r\r]r2s$!  cCst|dt|rtddSt}||_d|_|dksB|tjkrXt}| |g|}nt ||}||_| |g|}|r~|S| dS)a Broadcasts the tensor to the whole group. ``tensor`` must have the same number of elements in all processes participating in the collective. Args: tensor (Tensor): Data to be sent if ``src`` is the rank of current process, and tensor to be used to save received data otherwise. src (int): Source rank. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group rr1Nr) rrrrrnror$rrr1rSr)rrYr;rqrirr]r[r\r\r]r1Rs   cCsltdt|rdSdd|D}t}||_|dkrLt}|||}n |||}|r`|S|dS)a Reduces the tensor data across all machines in such a way that all get the final result. This function reduces a number of tensors on every node, while each tensor resides on different GPUs. Therefore, the input tensor in the tensor list needs to be GPU tensors. Also, each tensor in the tensor list needs to reside on a different GPU. After the call, all ``tensor`` in ``tensor_list`` is going to be bitwise identical in all processes. Complex tensors are supported. Only nccl and gloo backend is currently supported tensors should only be GPU tensors Args: tensor_list (List[Tensor]): List of input and output tensors of the collective. The function operates in-place and requires that each tensor to be a GPU tensor on different GPUs. You also need to make sure that ``len(tensor_list)`` is the same for all the distributed processes calling this function. op (optional): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If ``None``, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group ztorch.distributed.all_reduce_multigpu will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#multi-gpu-collective-functionsNcSs"g|]}|s|nt|qSr\rr view_as_realrtr\r\r] sz'all_reduce_multigpu..)rrrr rdr allreducer)rprr;rqrirr]r\r\r]r,|s"# cCst|dt|rtddS|rHt|s>td|dt|}t}||_ |dkrbt }|t j krtt|d|d}t j |||rtSdS||g|}|r|S|dS)a Reduces the tensor data across all machines in such a way that all get the final result. After the call ``tensor`` is going to be bitwise identical in all processes. Complex tensors are supported. Args: tensor (Tensor): Input and output of the collective. The function operates in-place. op (optional): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group Examples: >>> # xdoctest: +SKIP("no rank") >>> # All tensors below are of torch.int64 type. >>> # We have 2 process groups, 2 ranks. >>> tensor = torch.arange(2, dtype=torch.int64) + 1 + 2 * rank >>> tensor tensor([1, 2]) # Rank 0 tensor([3, 4]) # Rank 1 >>> dist.all_reduce(tensor, op=ReduceOp.SUM) >>> tensor tensor([4, 6]) # Rank 0 tensor([4, 6]) # Rank 1 >>> # All tensors below are of torch.cfloat type. >>> # We have 2 process groups, 2 ranks. >>> tensor = torch.tensor([1+1j, 2+2j], dtype=torch.cfloat) + 2 * rank * (1+1j) >>> tensor tensor([1.+1.j, 2.+2.j]) # Rank 0 tensor([3.+3.j, 4.+4.j]) # Rank 1 >>> dist.all_reduce(tensor, op=ReduceOp.SUM) >>> tensor tensor([4.+4.j, 6.+6.j]) # Rank 0 tensor([4.+4.j, 6.+6.j]) # Rank 1 rr*Nall_reduce does not support  on complex tensors)rrrrrRrrrsr rdrrrrrr*rr^rwr)rrr;rqricollr]r\r\r]r*s,1  cCstdt|dt|t|r0tddStdd|DrZt|sZtd|dd d |D}t }||_ |dkrt }| ||}n | ||}|r| S|dS) a WARNING: at this time individual shape checking is not implemented across nodes. For example, if the rank 0 node passes [torch.rand(4), torch.rand(2)] and the rank 1 node passes [torch.rand(2), torch.rand(2), torch.rand(2)], the allreduce operation will proceed without complaint and return erroneous outputs. This lack of shape checking results in significant performance improvements but users of this function should take extra care to ensure that each node passes in tensors whose shapes match across nodes. Reduces each tensor in tensors (residing on the same device) across all machines in such a way that all get the final result. After the call each tensor in tensors is going to bitwise identical in all processes. Complex tensors are supported. Args: tensors (List[Tensor]): Input and output of the collective. The function operates in-place. op (Optional[ReduceOp]): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (Optional[bool]): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. ztorch.distributed.all_reduce_coalesced will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#collective-functionsrr+Ncss|]}|VqdSrf)rrtr\r\r]r6sz'all_reduce_coalesced..rxrycSs"g|]}|s|nt|qSr\rrrtr\r\r]rv9sz(all_reduce_coalesced..)rrrrrranyrRrr rdrrf get_futurer)rrr;rqrirr]r\r\r]r+ s("  c Cstdt|rtddSt}||_||_||_|dksH|tj kr\t }| ||}nt ||} | |_| ||}|r|S| dS)a Reduces the tensor data on multiple GPUs across all machines. Each tensor in ``tensor_list`` should reside on a separate GPU Only the GPU of ``tensor_list[dst_tensor]`` on the process with rank ``dst`` is going to receive the final result. Only nccl backend is currently supported tensors should only be GPU tensors Args: tensor_list (List[Tensor]): Input and output GPU tensors of the collective. The function operates in-place. You also need to make sure that ``len(tensor_list)`` is the same for all the distributed processes calling this function. dst (int): Destination rank op (optional): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op dst_tensor (int, optional): Destination tensor rank within ``tensor_list`` Returns: Async work handle, if async_op is set to True. None, otherwise ztorch.distributed.reduce_multigpu will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#multi-gpu-collective-functionsrLN)rrrrrrdrnror$rrrKrSr) rprVrr;rqrrirr]rXr\r\r]rLHs&"  c Cst|dt|rtddSt}||_||_|dksB|tjkrXt}| |g|}nt ||}||_| |g|}|r~|S| dS)a  Reduces the tensor data across all machines. Only the process with rank ``dst`` is going to receive the final result. Args: tensor (Tensor): Input and output of the collective. The function operates in-place. dst (int): Destination rank op (optional): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group rrKN) rrrrrdrnr$rrrKrSr) rrVrr;rqrirr]rXr\r\r]rKs   cCsvtdt|rtddSdd|D}dd|D}|dkrVt}|||}n |||}|rj|S|dS)ak Gathers tensors from the whole group in a list. Each tensor in ``tensor_list`` should reside on a separate GPU Only nccl backend is currently supported tensors should only be GPU tensors Complex tensors are supported. Args: output_tensor_lists (List[List[Tensor]]): Output lists. It should contain correctly-sized tensors on each GPU to be used for output of the collective, e.g. ``output_tensor_lists[i]`` contains the all_gather result that resides on the GPU of ``input_tensor_list[i]``. Note that each element of ``output_tensor_lists`` has the size of ``world_size * len(input_tensor_list)``, since the function all gathers the result from every single GPU in the group. To interpret each element of ``output_tensor_lists[i]``, note that ``input_tensor_list[j]`` of rank k will be appear in ``output_tensor_lists[i][k * world_size + j]`` Also note that ``len(output_tensor_lists)``, and the size of each element in ``output_tensor_lists`` (each element is a list, therefore ``len(output_tensor_lists[i])``) need to be the same for all the distributed processes calling this function. input_tensor_list (List[Tensor]): List of tensors(on different GPUs) to be broadcast from current process. Note that ``len(input_tensor_list)`` needs to be the same for all the distributed processes calling this function. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group ztorch.distributed.all_gather_multigpu will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#multi-gpu-collective-functionsr(NcSsg|]}dd|DqS)cSs"g|]}|s|nt|qSr\rrrtr\r\r]rvsz2all_gather_multigpu...r\rlr\r\r]rvsz'all_gather_multigpu..cSs"g|]}|s|nt|qSr\rrrtr\r\r]rvs)rrrrr allgatherr)output_tensor_listsinput_tensor_listr;rqrr]r\r\r]r(s&. cCsTt}t||tj|}t| |}t | g |}||fSrf) ioBytesIO_picklerdumprZ ByteStorageZ _from_buffergetvalueZ ByteTensortoZ LongTensorZnumel)rrfZ byte_storageZ byte_tensor local_sizer\r\r]_object_to_tensors rcCs.|}|d|}tt|Srf)rnnumpytobytes _unpicklerrrload)r tensor_sizebufr\r\r]_tensor_to_object src st|rtddSt|}t||\}}t|d}tj|tj|dfddt|D}t |||dt t | | tj|tj|dfddt|D}t |||dt|D]B\} } | tj} | jtdkr| } || } t| | || <qdS) a Gathers picklable objects from the whole group into a list. Similar to :func:`all_gather`, but Python objects can be passed in. Note that the object must be picklable in order to be gathered. Args: object_list (list[Any]): Output list. It should be correctly sized as the size of the group for this collective and will contain the output. obj (Any): Pickable Python object to be broadcast from current process. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. Returns: None. If the calling rank is part of this group, the output of the collective will be populated into the input ``object_list``. If the calling rank is not part of the group, the passed in ``object_list`` will be unmodified. .. note:: Note that this API differs slightly from the :func:`all_gather` collective since it does not provide an ``async_op`` handle and thus will be a blocking call. .. note:: For NCCL-based processed groups, internal tensor representations of objects must be moved to the GPU device before communication takes place. In this case, the device used is given by ``torch.cuda.current_device()`` and it is the user's responsiblity to ensure that this is set so that each rank has an individual GPU, via ``torch.cuda.set_device()``. .. warning:: :func:`all_gather_object` uses ``pickle`` module implicitly, which is known to be insecure. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling. Only call this function with data you trust. .. warning:: Calling :func:`all_gather_object` with GPU tensors is not well supported and inefficient as it incurs GPU -> CPU transfer since tensors would be pickled. Please consider using :func:`all_gather` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> # Assumes world_size of 3. >>> gather_objects = ["foo", 12, {1: 2}] # any picklable object >>> output = [None for _ in gather_objects] >>> dist.all_gather_object(output, gather_objects[dist.get_rank()]) >>> output ['foo', 12, {1: 2}] r)Nrrrcsg|]}|jddqSr)dimZ unsqueezer9object_sizes_tensorr\r]rvS sz%all_gather_object..cs$g|]}||dqSrr\r9coalesced_output_tensormax_object_sizer\r]rv_ srn)rrrrr:rzeroslongr?r&rmaxitemresize_emptyuint8 enumerater[rrnr) object_listrr;current_device input_tensorrrLobject_size_listoutput_tensorsr:rrr\rrrr]r) s@5     cs,t|rtddSt}t|||t|}t||\}}t|d}tj|tj |dfddt |D} t | ||dt t | |||krtj|tj|dfddt |D} t|||kr| nd||d||krdSt| D]*\} } | tj} | | } t| | || <qdS) a Gathers picklable objects from the whole group in a single process. Similar to :func:`gather`, but Python objects can be passed in. Note that the object must be picklable in order to be gathered. Args: obj (Any): Input object. Must be picklable. object_gather_list (list[Any]): Output list. On the ``dst`` rank, it should be correctly sized as the size of the group for this collective and will contain the output. Must be ``None`` on non-dst ranks. (default is ``None``) dst (int, optional): Destination rank. (default is 0) group: (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. Returns: None. On the ``dst`` rank, ``object_gather_list`` will contain the output of the collective. .. note:: Note that this API differs slightly from the gather collective since it does not provide an async_op handle and thus will be a blocking call. .. note:: For NCCL-based processed groups, internal tensor representations of objects must be moved to the GPU device before communication takes place. In this case, the device used is given by ``torch.cuda.current_device()`` and it is the user's responsiblity to ensure that this is set so that each rank has an individual GPU, via ``torch.cuda.set_device()``. .. warning:: :func:`gather_object` uses ``pickle`` module implicitly, which is known to be insecure. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling. Only call this function with data you trust. .. warning:: Calling :func:`gather_object` with GPU tensors is not well supported and inefficient as it incurs GPU -> CPU transfer since tensors would be pickled. Please consider using :func:`gather` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> # Assumes world_size of 3. >>> gather_objects = ["foo", 12, {1: 2}] # any picklable object >>> output = [None for _ in gather_objects] >>> dist.gather_object( ... gather_objects[dist.get_rank()], ... output if dist.get_rank() == 0 else None, ... dst=0 ... ) >>> # On rank 0 >>> output ['foo', 12, {1: 2}] r6Nrrcsg|]}|jddqSrrr9rr\r]rv sz!gather_object..cs$g|]}||dqSrr\r9rr\r]rv s) gather_listrVr;)rrr9_validate_output_list_for_rankrrr:rrrr?r&rrrrrrr5rr[r)rZobject_gather_listrVr;my_rankrrrrLrrr:rrr\rr]r6m sP;      c s<t|rtddS|pt|t}||krTtfdd|D\}}t|}ntjt|tj d}t |||d||krt|dkr|d}qt|}ntjt | tj d}t |||dd} ||kr8t|D]T\} } || | | } | tj } | jtd kr | } | | 7} t| | || <qdS) a Broadcasts picklable objects in ``object_list`` to the whole group. Similar to :func:`broadcast`, but Python objects can be passed in. Note that all objects in ``object_list`` must be picklable in order to be broadcasted. Args: object_list (List[Any]): List of input objects to broadcast. Each object must be picklable. Only objects on the ``src`` rank will be broadcast, but each rank must provide lists of equal sizes. src (int): Source rank from which to broadcast ``object_list``. group: (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. device (``torch.device``, optional): If not None, the objects are serialized and converted to tensors which are moved to the ``device`` before broadcasting. Default is ``None``. Returns: ``None``. If rank is part of the group, ``object_list`` will contain the broadcasted objects from ``src`` rank. .. note:: For NCCL-based process groups, internal tensor representations of objects must be moved to the GPU device before communication takes place. In this case, the device used is given by ``torch.cuda.current_device()`` and it is the user's responsibility to ensure that this is set so that each rank has an individual GPU, via ``torch.cuda.set_device()``. .. note:: Note that this API differs slightly from the :func:`all_gather` collective since it does not provide an ``async_op`` handle and thus will be a blocking call. .. warning:: :func:`broadcast_object_list` uses ``pickle`` module implicitly, which is known to be insecure. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling. Only call this function with data you trust. .. warning:: Calling :func:`broadcast_object_list` with GPU tensors is not well supported and inefficient as it incurs GPU -> CPU transfer since tensors would be pickled. Please consider using :func:`broadcast` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> if dist.get_rank() == 0: >>> # Assumes world_size of 3. >>> objects = ["foo", 12, {1: 2}] # any picklable object >>> else: >>> objects = [None, None, None] >>> # Assumes backend is not NCCL >>> device = torch.device("cpu") >>> dist.broadcast_object_list(objects, src=0, device=device) >>> objects ['foo', 12, {1: 2}] r3Ncsg|]}t|qSr\rrrrr\r]rv% sz)broadcast_object_list..rrYr;rrrn)rrrr9ziprcatrrrr1sumrrrr[rrnr) rrYr;rrrpZ size_listrZ object_tensoroffsetr:Zobj_sizeZobj_viewr\rr]r3 s:<        c s2t|rtddSt|tr*t|dkr2tdt}t|||krttfdd|D\}}t|t|}}||krt |}|D]}| |qnt j dgt j d}t|||d t j|t jd} t| ||krdn|||d t j dgt j d} t| ||krdn|||d t| | |d<dS) a Scatters picklable objects in ``scatter_object_input_list`` to the whole group. Similar to :func:`scatter`, but Python objects can be passed in. On each rank, the scattered object will be stored as the first element of ``scatter_object_output_list``. Note that all objects in ``scatter_object_input_list`` must be picklable in order to be scattered. Args: scatter_object_output_list (List[Any]): Non-empty list whose first element will store the object scattered to this rank. scatter_object_input_list (List[Any]): List of input objects to scatter. Each object must be picklable. Only objects on the ``src`` rank will be scattered, and the argument can be ``None`` for non-src ranks. src (int): Source rank from which to scatter ``scatter_object_input_list``. group: (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. Returns: ``None``. If rank is part of the group, ``scatter_object_output_list`` will have its first element set to the scattered object for this rank. .. note:: Note that this API differs slightly from the scatter collective since it does not provide an ``async_op`` handle and thus will be a blocking call. .. warning:: :func:`scatter_object_list` uses ``pickle`` module implicitly, which is known to be insecure. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling. Only call this function with data you trust. .. warning:: Calling :func:`scatter_object_list` with GPU tensors is not well supported and inefficient as it incurs GPU -> CPU transfer since tensors would be pickled. Please consider using :func:`scatter` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> if dist.get_rank() == 0: >>> # Assumes world_size of 3. >>> objects = ["foo", 12, {1: 2}] # any picklable object >>> else: >>> # Can be any list on non-src ranks, elements are not used. >>> objects = [None, None, None] >>> output_list = [None] >>> dist.scatter_object_list(output_list, objects, src=0) >>> # Rank i gets objects[i]. For example, on rank 2: >>> output_list [{1: 2}] rPNrzMExpected argument scatter_object_output_list to be a list of size at least 1.csg|]}t|qSr\rrZ pg_devicer\r]rv sz'scatter_object_list..rrr) scatter_listrYr;)rrrtrrrr9rrrrrrrr1rrrrOr) Zscatter_object_output_listZscatter_object_input_listrYr;rrpZ tensor_sizesZmax_tensor_sizer output_tensorZobj_tensor_sizer\rr]rPI sL9 cCst|dt|dt||t|r2tddSdd|D}|sL|nt|}|dkrvt}| |g|g}n| |g|g}|r|S| dS)a Gathers tensors from the whole group in a list. Complex tensors are supported. Args: tensor_list (list[Tensor]): Output list. It should contain correctly-sized tensors to be used for output of the collective. tensor (Tensor): Tensor to be broadcast from current process. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group Examples: >>> # xdoctest: +SKIP("need process group init") >>> # All tensors below are of torch.int64 dtype. >>> # We have 2 process groups, 2 ranks. >>> tensor_list = [torch.zeros(2, dtype=torch.int64) for _ in range(2)] >>> tensor_list [tensor([0, 0]), tensor([0, 0])] # Rank 0 and 1 >>> tensor = torch.arange(2, dtype=torch.int64) + 1 + 2 * rank >>> tensor tensor([1, 2]) # Rank 0 tensor([3, 4]) # Rank 1 >>> dist.all_gather(tensor_list, tensor) >>> tensor_list [tensor([1, 2]), tensor([3, 4])] # Rank 0 [tensor([1, 2]), tensor([3, 4])] # Rank 1 >>> # All tensors below are of torch.cfloat dtype. >>> # We have 2 process groups, 2 ranks. >>> tensor_list = [torch.zeros(2, dtype=torch.cfloat) for _ in range(2)] >>> tensor_list [tensor([0.+0.j, 0.+0.j]), tensor([0.+0.j, 0.+0.j])] # Rank 0 and 1 >>> tensor = torch.tensor([1+1j, 2+2j], dtype=torch.cfloat) + 2 * rank * (1+1j) >>> tensor tensor([1.+1.j, 2.+2.j]) # Rank 0 tensor([3.+3.j, 4.+4.j]) # Rank 1 >>> dist.all_gather(tensor_list, tensor) >>> tensor_list [tensor([1.+1.j, 2.+2.j]), tensor([3.+3.j, 4.+4.j])] # Rank 0 [tensor([1.+1.j, 2.+2.j]), tensor([3.+3.j, 4.+4.j])] # Rank 1 rprr&NcSs"g|]}|s|nt|qSr\rrrtr\r\r]rv szall_gather..) rrrrrrrrsrrr)rprr;rqrr]r\r\r]r& s"2   cCst|dt|dt|r(tddS|s4|nt|}|sJ|nt|}|p\t}|tj krt t ||}tj| ||rt SdS|||}|r|S|dS)aH Gather tensors from all ranks and put them in a single output tensor. Args: output_tensor (Tensor): Output tensor to accommodate tensor elements from all ranks. It must be correctly sized to have one of the following forms: (i) a concatenation of all the input tensors along the primary dimension; for definition of "concatenation", see ``torch.cat()``; (ii) a stack of all the input tensors along the primary dimension; for definition of "stack", see ``torch.stack()``. Examples below may better explain the supported output forms. input_tensor (Tensor): Tensor to be gathered from current rank. Different from the ``all_gather`` API, the input tensors in this API must have the same size across all ranks. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group Examples: >>> # xdoctest: +SKIP("need process group init") >>> # All tensors below are of torch.int64 dtype and on CUDA devices. >>> # We have two ranks. >>> device = torch.device(f'cuda:{rank}') >>> tensor_in = torch.arange(2, dtype=torch.int64, device=device) + 1 + 2 * rank >>> tensor_in tensor([1, 2], device='cuda:0') # Rank 0 tensor([3, 4], device='cuda:1') # Rank 1 >>> # Output in concatenation form >>> tensor_out = torch.zeros(world_size * 2, dtype=torch.int64, device=device) >>> dist.all_gather_into_tensor(tensor_out, tensor_in) >>> tensor_out tensor([1, 2, 3, 4], device='cuda:0') # Rank 0 tensor([1, 2, 3, 4], device='cuda:1') # Rank 1 >>> # Output in stack form >>> tensor_out2 = torch.zeros(world_size, 2, dtype=torch.int64, device=device) >>> dist.all_gather_into_tensor(tensor_out2, tensor_in) >>> tensor_out2 tensor([[1, 2], [3, 4]], device='cuda:0') # Rank 0 tensor([[1, 2], [3, 4]], device='cuda:1') # Rank 1 .. warning:: The Gloo backend does not support this API. rrrWN)rrrrrrsrrrrrrWrr^Z_allgather_baser)rrr;rqrzr]r\r\r]rW s05     cCstdt||||S)a$ Single tensor all gather. Gathers a single tensor from all ranks, and puts them in a single output tensor. Args: output_tensor (Tensor): Output tensor. It should contain correctly-sized tensors to be used for output of the collective. input_tensor (Tensor): Tensor to be broadcast from current process. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group .. warning:: `_all_gather_base` is a private function. Users should use `all_gather_into_tensor` instead. ztorch.distributed._all_gather_base is a private function and will be deprecated. Please use torch.distributed.all_gather_into_tensor instead.)rrrW)rrr;rqr\r\r]_all_gather_baseY srcCstdt|rtddSt|dt|t|tsBtd|D]}t|dt|qFdd|D}d d|D}|dkrt }| ||}n | ||}|r| S| dS) a Gathers input tensors from the whole group in a list in a coalesced manner. Complex tensors are supported. Args: output_tensor_lists (list[list[Tensor]]): Output list. It should contain correctly-sized tensors to be used for output of the collective. input_tensor_list (list[Tensor]): Tensors to be broadcast from current process. At least one tensor has to be non empty. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group Example: we have 2 process groups, 2 ranks. rank 0 passes: input_tensor_list = [[[1, 1], [1, 1]], [2], [3, 3]] output_tensor_lists = [[[[-1, -1], [-1, -1]], [-1], [-1, -1]], [[[-1, -1], [-1, -1]], [-1], [-1, -1]]] rank 1 passes: input_tensor_list = [[[3, 3], [3, 3]], [5], [1, 1]] output_tensor_lists = [[[[-1, -1], [-1, -1]], [-1], [-1, -1]], [[[-1, -1], [-1, -1]], [-1], [-1, -1]]] both rank 0 and 1 get: output_tensor_lists = [[[1, 1], [1, 1]], [2], [3, 3]], [[3, 3], [3, 3]], [5], [1, 1]]]. WARNING: at this time individual shape checking is not implemented across nodes. For example, if the rank 0 node passes [torch.rand(4), torch.rand(2)] and the rank 1 node passes [torch.rand(2), torch.rand(2), torch.rand(2)], the all_gather_coalesced operation will proceed without complaint and return erroneous outputs. This lack of shape checking results in significant performance improvements but users of this function should take extra care to ensure that each node passes in tensors whose shapes match across nodes. ztorch.distributed.all_gather_coalesced will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#collective-functionsr'Nrz?Invalid function argument: output_tensor_lists should be a listrcSsg|]}dd|DqS)cSs"g|]}|s|nt|qSr\rrrtr\r\r]rv sz3all_gather_coalesced...r\r}r\r\r]rv sz(all_gather_coalesced..cSs"g|]}|s|nt|qSr\rrrtr\r\r]rv s) rrrrrrrtrrrZallgather_coalescedr|r)rrr;rqoutput_tensor_listrr]r\r\r]r'w s8/     cCs&||kr|s"tdn |r"tddS)Nz?Argument ``gather_list`` must be specified on destination rank.zHArgument ``gather_list`` must NOT be specified on non-destination ranks.)rv)rrVrr\r\r]r src Cst|d|rt|dng}t||t|r>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> tensor_size = 2 >>> t_ones = torch.ones(tensor_size) >>> t_fives = torch.ones(tensor_size) * 5 >>> output_tensor = torch.zeros(tensor_size) >>> if dist.get_rank() == 0: >>> # Assumes world_size of 2. >>> # Only tensors, all of which must be the same size. >>> scatter_list = [t_ones, t_fives] >>> else: >>> scatter_list = None >>> dist.scatter(output_tensor, scatter_list, src=0) >>> # Rank i gets scatter_list[i]. For example, on rank 1: >>> output_tensor tensor([5., 5.]) rrrONcSs"g|]}|s|nt|qSr\rrrtr\r\r]rvK szscatter..z;Argument ``scatter_list`` must be specified on source rank.zDArgument ``scatter_list`` must NOT be specified on non-source ranks.)rrrrrrrrsr9rvrrnr$rrrOrSr) rrrYr;rqrrrrirr]r[r\r\r]rO sJ-    cCsjtdt|rtddSt}||_|dkrHt}||||}n||||}|r^|S|dS)a Reduce and scatter a list of tensors to the whole group. Only nccl backend is currently supported. Each tensor in ``output_tensor_list`` should reside on a separate GPU, as should each list of tensors in ``input_tensor_lists``. Args: output_tensor_list (List[Tensor]): Output tensors (on different GPUs) to receive the result of the operation. Note that ``len(output_tensor_list)`` needs to be the same for all the distributed processes calling this function. input_tensor_lists (List[List[Tensor]]): Input lists. It should contain correctly-sized tensors on each GPU to be used for input of the collective, e.g. ``input_tensor_lists[i]`` contains the reduce_scatter input that resides on the GPU of ``output_tensor_list[i]``. Note that each element of ``input_tensor_lists`` has the size of ``world_size * len(output_tensor_list)``, since the function scatters the result from every single GPU in the group. To interpret each element of ``input_tensor_lists[i]``, note that ``output_tensor_list[j]`` of rank k receives the reduce-scattered result from ``input_tensor_lists[i][k * world_size + j]`` Also note that ``len(input_tensor_lists)``, and the size of each element in ``input_tensor_lists`` (each element is a list, therefore ``len(input_tensor_lists[i])``) need to be the same for all the distributed processes calling this function. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. ztorch.distributed.reduce_scatter_multigpu will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/master/distributed.html#multi-gpu-collective-functionsrNN) rrrrrrdrrMr)rZinput_tensor_listsrr;rqrirr]r\r\r]rNr s-cCst|dt|dt||t|r2tddSt}||_|dkr`t}||g|g|}n||g|g|}|rz|S| dS)a Reduces, then scatters a list of tensors to all processes in a group. Args: output (Tensor): Output tensor. input_list (list[Tensor]): List of tensors to reduce and scatter. op (optional): One of the values from ``torch.distributed.ReduceOp`` enum. Specifies an operation used for element-wise reductions. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. output input_listrMN) rrrrrrrdrrMr)rrrr;rqrirr]r\r\r]rM s   cCst|dt|dt|r(tddSt}||_|p>> # xdoctest: +SKIP("need process group init") >>> # All tensors below are of torch.int64 dtype and on CUDA devices. >>> # We have two ranks. >>> device = torch.device(f'cuda:{rank}') >>> tensor_out = torch.zeros(2, dtype=torch.int64, device=device) >>> # Input in concatenation form >>> tensor_in = torch.arange(world_size * 2, dtype=torch.int64, device=device) >>> tensor_in tensor([0, 1, 2, 3], device='cuda:0') # Rank 0 tensor([0, 1, 2, 3], device='cuda:1') # Rank 1 >>> dist.reduce_scatter_tensor(tensor_out, tensor_in) >>> tensor_out tensor([0, 2], device='cuda:0') # Rank 0 tensor([4, 6], device='cuda:1') # Rank 1 >>> # Input in stack form >>> tensor_in = torch.reshape(tensor_in, (world_size, 2)) >>> tensor_in tensor([[0, 1], [2, 3]], device='cuda:0') # Rank 0 tensor([[0, 1], [2, 3]], device='cuda:1') # Rank 1 >>> dist.reduce_scatter_tensor(tensor_out, tensor_in) >>> tensor_out tensor([0, 2], device='cuda:0') # Rank 0 tensor([4, 6], device='cuda:1') # Rank 1 .. warning:: The Gloo backend does not support this API. rinputrXN)rrrrrdrrrrrrXrr^_reduce_scatter_baser)rrrr;rqrirzr]r\r\r]rX s$7   cCstdt|||||S)a Reduces, then scatters a flattened tensor to all processes in a group. Args: output (Tensor): Output tensor. input (Tensor): Input tensor that is of size output tensor size times world size group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. .. warning:: `_reduce_scatter_base` is a private function. Users should use `reduce_scatter_tensor` instead. ztorch.distributed._reduce_scatter_base is a private function and will be deprecated. Please use torch.distributed.reduce_scatter_tensor instead.)rrrX)rrrr;rqr\r\r]r7 src Cst|rtddSt}t|dt|dt|||rJt|}|r\t|}|dkrhgn|}|dkrxgn|}|dkrt}| |||||}n| |||||}|r|S| dS)a Each process splits input tensor and then scatters the split list to all processes in a group. Then concatenate the received tensors from all the processes in the group and return single output tensor. Complex tensors are supported. Args: output (Tensor): Gathered concatenated output tensor. input (Tensor): Input tensor to scatter. output_split_sizes: (list[Int], optional): Output split sizes for dim 0 if specified None or empty, dim 0 of ``output`` tensor must divide equally by ``world_size``. input_split_sizes: (list[Int], optional): Input split sizes for dim 0 if specified None or empty, dim 0 of ``input`` tensor must divide equally by ``world_size``. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. .. warning:: `all_to_all_single` is experimental and subject to change. Examples: >>> # xdoctest: +SKIP("Undefined rank") >>> input = torch.arange(4) + rank * 4 >>> input tensor([0, 1, 2, 3]) # Rank 0 tensor([4, 5, 6, 7]) # Rank 1 tensor([8, 9, 10, 11]) # Rank 2 tensor([12, 13, 14, 15]) # Rank 3 >>> output = torch.empty([4], dtype=torch.int64) >>> dist.all_to_all_single(output, input) >>> output tensor([0, 4, 8, 12]) # Rank 0 tensor([1, 5, 9, 13]) # Rank 1 tensor([2, 6, 10, 14]) # Rank 2 tensor([3, 7, 11, 15]) # Rank 3 >>> # Essentially, it is similar to following operation: >>> scatter_list = list(input.chunk(world_size)) >>> gather_list = list(output.chunk(world_size)) >>> for i in range(world_size): >>> dist.scatter(gather_list[i], scatter_list if i == rank else [], src = i) >>> # Another example with uneven split >>> input tensor([0, 1, 2, 3, 4, 5]) # Rank 0 tensor([10, 11, 12, 13, 14, 15, 16, 17, 18]) # Rank 1 tensor([20, 21, 22, 23, 24]) # Rank 2 tensor([30, 31, 32, 33, 34, 35, 36]) # Rank 3 >>> input_splits [2, 2, 1, 1] # Rank 0 [3, 2, 2, 2] # Rank 1 [2, 1, 1, 1] # Rank 2 [2, 2, 2, 1] # Rank 3 >>> output_splits [2, 3, 2, 2] # Rank 0 [2, 2, 1, 2] # Rank 1 [1, 2, 1, 2] # Rank 2 [1, 2, 1, 1] # Rank 3 >>> output = ... >>> dist.all_to_all_single(output, input, output_splits, input_splits) >>> output tensor([ 0, 1, 10, 11, 12, 20, 21, 30, 31]) # Rank 0 tensor([ 2, 3, 13, 14, 22, 32, 33]) # Rank 1 tensor([ 4, 15, 16, 23, 34, 35]) # Rank 2 tensor([ 5, 17, 18, 24, 36]) # Rank 3 >>> # Another example with tensors of torch.cfloat type. >>> input = torch.tensor([1+1j, 2+2j, 3+3j, 4+4j], dtype=torch.cfloat) + 4 * rank * (1+1j) >>> input tensor([1+1j, 2+2j, 3+3j, 4+4j]) # Rank 0 tensor([5+5j, 6+6j, 7+7j, 8+8j]) # Rank 1 tensor([9+9j, 10+10j, 11+11j, 12+12j]) # Rank 2 tensor([13+13j, 14+14j, 15+15j, 16+16j]) # Rank 3 >>> output = torch.empty([4], dtype=torch.int64) >>> dist.all_to_all_single(output, input) >>> output tensor([1+1j, 5+5j, 9+9j, 13+13j]) # Rank 0 tensor([2+2j, 6+6j, 10+10j, 14+14j]) # Rank 1 tensor([3+3j, 7+7j, 11+11j, 15+15j]) # Rank 2 tensor([4+4j, 8+8j, 12+12j, 16+16j]) # Rank 3 r.Nrr) rrr rrrrrsrZ alltoall_baser) rrZoutput_split_sizesZinput_split_sizesr;rqrirr]r\r\r]r.S s@b     cCst|rtddSt}t|dt|dt||dd|D}dd|D}|dkrrt}||||}n||||}|r|S|dS)a Each process scatters list of input tensors to all processes in a group and return gathered list of tensors in output list. Complex tensors are supported. Args: output_tensor_list (list[Tensor]): List of tensors to be gathered one per rank. input_tensor_list (list[Tensor]): List of tensors to scatter one per rank. group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group. .. warning:: `all_to_all` is experimental and subject to change. Examples: >>> # xdoctest: +SKIP("Undefined rank") >>> input = torch.arange(4) + rank * 4 >>> input = list(input.chunk(4)) >>> input [tensor([0]), tensor([1]), tensor([2]), tensor([3])] # Rank 0 [tensor([4]), tensor([5]), tensor([6]), tensor([7])] # Rank 1 [tensor([8]), tensor([9]), tensor([10]), tensor([11])] # Rank 2 [tensor([12]), tensor([13]), tensor([14]), tensor([15])] # Rank 3 >>> output = list(torch.empty([4], dtype=torch.int64).chunk(4)) >>> dist.all_to_all(output, input) >>> output [tensor([0]), tensor([4]), tensor([8]), tensor([12])] # Rank 0 [tensor([1]), tensor([5]), tensor([9]), tensor([13])] # Rank 1 [tensor([2]), tensor([6]), tensor([10]), tensor([14])] # Rank 2 [tensor([3]), tensor([7]), tensor([11]), tensor([15])] # Rank 3 >>> # Essentially, it is similar to following operation: >>> scatter_list = input >>> gather_list = output >>> for i in range(world_size): >>> dist.scatter(gather_list[i], scatter_list if i == rank else [], src=i) >>> input tensor([0, 1, 2, 3, 4, 5]) # Rank 0 tensor([10, 11, 12, 13, 14, 15, 16, 17, 18]) # Rank 1 tensor([20, 21, 22, 23, 24]) # Rank 2 tensor([30, 31, 32, 33, 34, 35, 36]) # Rank 3 >>> input_splits [2, 2, 1, 1] # Rank 0 [3, 2, 2, 2] # Rank 1 [2, 1, 1, 1] # Rank 2 [2, 2, 2, 1] # Rank 3 >>> output_splits [2, 3, 2, 2] # Rank 0 [2, 2, 1, 2] # Rank 1 [1, 2, 1, 2] # Rank 2 [1, 2, 1, 1] # Rank 3 >>> input = list(input.split(input_splits)) >>> input [tensor([0, 1]), tensor([2, 3]), tensor([4]), tensor([5])] # Rank 0 [tensor([10, 11, 12]), tensor([13, 14]), tensor([15, 16]), tensor([17, 18])] # Rank 1 [tensor([20, 21]), tensor([22]), tensor([23]), tensor([24])] # Rank 2 [tensor([30, 31]), tensor([32, 33]), tensor([34, 35]), tensor([36])] # Rank 3 >>> output = ... >>> dist.all_to_all(output, input) >>> output [tensor([0, 1]), tensor([10, 11, 12]), tensor([20, 21]), tensor([30, 31])] # Rank 0 [tensor([2, 3]), tensor([13, 14]), tensor([22]), tensor([32, 33])] # Rank 1 [tensor([4]), tensor([15, 16]), tensor([23]), tensor([34, 35])] # Rank 2 [tensor([5]), tensor([17, 18]), tensor([24]), tensor([36])] # Rank 3 >>> # Another example with tensors of torch.cfloat type. >>> input = torch.tensor([1+1j, 2+2j, 3+3j, 4+4j], dtype=torch.cfloat) + 4 * rank * (1+1j) >>> input = list(input.chunk(4)) >>> input [tensor([1+1j]), tensor([2+2j]), tensor([3+3j]), tensor([4+4j])] # Rank 0 [tensor([5+5j]), tensor([6+6j]), tensor([7+7j]), tensor([8+8j])] # Rank 1 [tensor([9+9j]), tensor([10+10j]), tensor([11+11j]), tensor([12+12j])] # Rank 2 [tensor([13+13j]), tensor([14+14j]), tensor([15+15j]), tensor([16+16j])] # Rank 3 >>> output = list(torch.empty([4], dtype=torch.int64).chunk(4)) >>> dist.all_to_all(output, input) >>> output [tensor([1+1j]), tensor([5+5j]), tensor([9+9j]), tensor([13+13j])] # Rank 0 [tensor([2+2j]), tensor([6+6j]), tensor([10+10j]), tensor([14+14j])] # Rank 1 [tensor([3+3j]), tensor([7+7j]), tensor([11+11j]), tensor([15+15j])] # Rank 2 [tensor([4+4j]), tensor([8+8j]), tensor([12+12j]), tensor([16+16j])] # Rank 3 r-NrrcSs"g|]}|s|nt|qSr\rrrtr\r\r]rv;szall_to_all..cSs"g|]}|s|nt|qSr\rrrtr\r\r]rv>s)rrr rrrZalltoallr)rrr;rqrirr]r\r\r]r- s(\   cCst|rtddSt}t||_|dk rFt|tr>||_ntd|dkrbt }|j |d}n |j |d}|rv|S| dS)aR Synchronizes all processes. This collective blocks processes until the whole group enters this function, if async_op is False, or if async work handle is called on wait(). Args: group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. async_op (bool, optional): Whether this op should be an async op device_ids ([int], optional): List of device/GPU ids. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group r/Nz>Invalid function argument: device_ids type should be List[int])ri) rrrrrrtr device_idsrrr/r)r;rqrrirr]r\r\r]r/Ms$   cCsVt|rtddSt|tjkr*td|dkr6t}|dkrDtn|}|j||dS)a Synchronizes all processes similar to ``torch.distributed.barrier``, but takes a configurable timeout and is able to report ranks that did not pass this barrier within that timeout. Specifically, for non-zero ranks, will block until a send/recv is processed from rank 0. Rank 0 will block until all send /recv from other ranks are processed, and will report failures for ranks that failed to respond in time. Note that if one rank does not reach the monitored_barrier (for example due to a hang), all other ranks would fail in monitored_barrier. This collective will block all processes/ranks in the group, until the whole group exits the function successfully, making it useful for debugging and synchronizing. However, it can have a performance impact and should only be used for debugging or scenarios that require full synchronization points on the host-side. For debugging purposes, this barrier can be inserted before the application's collective calls to check if any ranks are desynchronized. .. note:: Note that this collective is only supported with the GLOO backend. Args: group (ProcessGroup, optional): The process group to work on. If ``None``, the default process group will be used. timeout (datetime.timedelta, optional): Timeout for monitored_barrier. If ``None``, the default process group timeout will be used. wait_all_ranks (bool, optional): Whether to collect all failed ranks or not. By default, this is ``False`` and ``monitored_barrier`` on rank 0 will throw on the first failed rank it encounters in order to fail fast. By setting ``wait_all_ranks=True`` ``monitored_barrier`` will collect all failed ranks and throw an error containing information about all failed ranks. Returns: ``None``. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> if dist.get_rank() != 1: >>> dist.monitored_barrier() # Raises exception indicating that >>> # rank 1 did not call into monitored_barrier. >>> # Example with wait_all_ranks=True >>> if dist.get_rank() == 0: >>> dist.monitored_barrier(wait_all_ranks=True) # Raises exception >>> # indicating that ranks 1, 2, ... world_size - 1 did not call into >>> # monitored_barrier. rFNz7monitored_barrier is only implemented for GLOO backend.)wait_all_ranks) rrr8r"rrrrrF)r;rrZ group_to_user\r\r]rFzs4rBcCs6td|}t||}t||||d}t||}|S)Nrr8)PG_WRAPPER_STORE_PREFIXrrarb)rCrDrrrrprefixZ helper_pgr\r\r]rOs   rOcCsj|rNttdtt|d}|tj krftt|dd}q$nttj }tj d7_ |S)Nr+zutf-8r) hashlibsha1bytesrrru hexdigestrrrGr)rr7Zpg_namer\r\r]r<s  r<cCs|stt}t|Srf)r8rr"rr\r\r]_get_backend_from_strs rcCst||||d|dS)a Creates a new distributed group. This function requires that all processes in the main group (i.e. all processes that are part of the distributed job) enter this function, even if they are not going to be members of the group. Additionally, groups should be created in the same order in all processes. .. warning:: Using multiple process groups with the ``NCCL`` backend concurrently is not safe and the user should perform explicit synchronization in their application to ensure only one process group is used at a time. This means collectives from one process group should have completed execution on the device (not just enqueued since CUDA execution is async) before collectives from another process group are enqueued. See `Using multiple NCCL communicators concurrently `_ for more details. Args: ranks (list[int]): List of ranks of group members. If ``None``, will be set to all ranks. Default is ``None``. timeout (timedelta, optional): Timeout for operations executed against the process group. Default value equals 30 minutes. This is applicable for the ``gloo`` backend. For ``nccl``, this is applicable only if the environment variable ``NCCL_BLOCKING_WAIT`` or ``NCCL_ASYNC_ERROR_HANDLING`` is set to 1. When ``NCCL_BLOCKING_WAIT`` is set, this is the duration for which the process will block and wait for collectives to complete before throwing an exception. When ``NCCL_ASYNC_ERROR_HANDLING`` is set, this is the duration after which collectives will be aborted asynchronously and the process will crash. ``NCCL_BLOCKING_WAIT`` will provide errors to the user which can be caught and handled, but due to its blocking nature, it has a performance overhead. On the other hand, ``NCCL_ASYNC_ERROR_HANDLING`` has very little performance overhead, but crashes the process on errors. This is done since CUDA execution is async and it is no longer safe to continue executing user code since failed async NCCL operations might result in subsequent CUDA operations running on corrupted data. Only one of these two environment variables should be set. backend (str or Backend, optional): The backend to use. Depending on build-time configurations, valid values are ``gloo`` and ``nccl``. By default uses the same backend as the global group. This field should be given as a lowercase string (e.g., ``"gloo"``), which can also be accessed via :class:`Backend` attributes (e.g., ``Backend.GLOO``). If ``None`` is passed in, the backend corresponding to the default process group will be used. Default is ``None``. pg_options (ProcessGroupOptions, optional): process group options specifying what additional options need to be passed in during the construction of specific process groups. i.e. for the ``nccl`` backend, ``is_high_priority_stream`` can be specified so that process group can pick up high priority cuda streams. use_local_synchronization (bool, optional): perform a group-local barrier at the end of the process group creation. This is different in that non-member ranks don't need to call into API and don't join the barrier. Returns: A handle of distributed group that can be given to collective calls or None if the rank is not part of ``ranks``. N.B. use_local_synchronization doesn't work with MPI. N.B. While use_local_synchronization=True can be significantly faster with larger clusters and small process groups, care must be taken since it changes cluster behavior as non-member ranks don't join the group barrier(). N.B. use_local_synchronization=True can lead to deadlocks when each rank creates multiple overlaping process groups. To avoid that, make sure all ranks follow the same global creation order. N)use_local_synchronization)_new_group_with_tag)rrrr4rr\r\r]rGsIc Cszt}tj|\}}|} |} |s,|}t|}|r`|tjkrJtd|dk r`t|kr`dS|dk rt |}t |} | | krtd|D]} | dks| | krtdq| |kr| | } qd} nt t | }| } | } t||d}t| | |||||||d \}}dd t|Dtj|<td krvtd |tjkrDtn2|rN|n|}|r`t |nt}t| |||||S) z This is a variant of ``new_group`` that exposes tag creation. :: N.B. The mechanism is experimental and tied to the functional collectives effort, see ``torch.distributed._functional_collectives`` for reference on how to use it. z:MPI backend doesn't support use_local_synchronization=TrueNz^the new group's world size should be less or equal to the world size set by init_process_grouprzRThe new group's rank should be within the the world_size set by init_process_groupr6)rr4rrQcSsi|]\}}||qSr\r\)rrrr\r\r]rusz'_new_group_with_tag..rr;)rrrrr r"rrr9sortedrindexrr?r<r=rrr)rrr/r:r)rrrr4rQrrZdefault_backendr,rZglobal_world_sizeZgroup_world_sizerrrrr1Z barrier_storerr\r\r]r+sn        rcCs|dkr$tjstdtj}|dkr`_ for more details. Args: group_size (int, optional): The size of each subgroup. If ``None``, the default subgroup size is equal to the number of devices on each machine, based on the assumption that each machine has exactly the same number of devices. Default is ``None``. timeout (timedelta, optional): Timeout for operations executed against the process group. Default value equals 30 minutes. This is applicable for the ``gloo`` backend. For ``nccl``, this is applicable only if the environment variable ``NCCL_BLOCKING_WAIT`` or ``NCCL_ASYNC_ERROR_HANDLING`` is set to 1. When ``NCCL_BLOCKING_WAIT`` is set, this is the duration for which the process will block and wait for collectives to complete before throwing an exception. When ``NCCL_ASYNC_ERROR_HANDLING`` is set, this is the duration after which collectives will be aborted asynchronously and the process will crash. ``NCCL_BLOCKING_WAIT`` will provide errors to the user which can be caught and handled, but due to its blocking nature, it has a performance overhead. On the other hand, ``NCCL_ASYNC_ERROR_HANDLING`` has very little performance overhead, but crashes the process on errors. This is done since CUDA execution is async and it is no longer safe to continue executing user code since failed async NCCL operations might result in subsequent CUDA operations running on corrupted data. Only one of these two environment variables should be set. backend (str or Backend, optional): The backend to use. Depending on build-time configurations, valid values are ``gloo`` and ``nccl``. By default uses the same backend as the global group. This field should be given as a lowercase string (e.g., ``"gloo"``), which can also be accessed via :class:`Backend` attributes (e.g., ``Backend.GLOO``). If ``None`` is passed in, the backend corresponding to the default process group will be used. Default is ``None``. pg_options (ProcessGroupOptions, optional): process group options specifying what additional options need to be passed in during the construction of specific process groups. i.e. for the ``nccl`` backend, ``is_high_priority_stream`` can be specified so that process group can pick up high priority cuda streams. Returns: The subgroup containing the current rank, and all the subgroups used for cleanup. Examples: >>> # Create intra-machine subgroups. >>> # xdoctest: +SKIP("need process group init") >>> cur_subgroup, subgroups = dist.new_subgroups() >>> # Allreduce within the machine. >>> rank = dist.get_rank() >>> tensor = torch.ones(1, device=rank) * rank >>> dist.all_reduce(tensor, group=cur_subgroup) >>> tensor tensor([8]) # Assume 8 is the number of CUDA devices per machine. >>> # Cleanup. >>> for subgroup in subgroups: >>> dist.destroy_process_group(subgroup) NzDefault group size only takes effect when CUDA is available.If your subgroup using a backend that does not depend on CUDA,please pass in 'group_size' correctly.rzThe arg 'group_size' (z) must be positivez") must not exceed the world size ()z0The world size must be divisible by 'group_size'rrrr4"Rank %s is assigned to subgroup %s) rroZ is_availablervZ device_countr:r?rrGrr9rr)rLr;rrr4r subgroups cur_subgroupZ subgroup_idZ start_rankZend_rankZranks_in_subgroupsubgrouprr\r\r]rHsB[    c Cs|dkst|dkrtdg}d}i}|D]v}t||||d}||t} |D]L} | |kr~td| d|| d|||| <| | krT|}td| |qTq,||fS) a[ Creates subgroups by dividing the global world, where the division is specified by a nested list of ranks. The subgroups cannot have overlap, and some ranks may not have to be in any subgroup. This is a convenience API that calls ``new_group`` to generate multiple subgroups. It requires that all processes in the main group (i.e. all processes that are part of the distributed job) enter this function, even if they are not going to be members of the group. .. warning:: Using multiple process groups with the ``NCCL`` backend concurrently is not safe and the user should perform explicit synchronization in their application to ensure only one process group is used at a time. This means collectives from one process group should have completed execution on the device (not just enqueued since CUDA execution is async) before collectives from another process group are enqueued. See `Using multiple NCCL communicators concurrently `_ for more details. Args: ranks_per_subgroup_list (list[list[int]]): A nested list of ranks of group members. timeout (timedelta, optional): Timeout for operations executed against the process group. Default value equals 30 minutes. This is applicable for the ``gloo`` backend. For ``nccl``, this is applicable only if the environment variable ``NCCL_BLOCKING_WAIT`` or ``NCCL_ASYNC_ERROR_HANDLING`` is set to 1. When ``NCCL_BLOCKING_WAIT`` is set, this is the duration for which the process will block and wait for collectives to complete before throwing an exception. When ``NCCL_ASYNC_ERROR_HANDLING`` is set, this is the duration after which collectives will be aborted asynchronously and the process will crash. ``NCCL_BLOCKING_WAIT`` will provide errors to the user which can be caught and handled, but due to its blocking nature, it has a performance overhead. On the other hand, ``NCCL_ASYNC_ERROR_HANDLING`` has very little performance overhead, but crashes the process on errors. This is done since CUDA execution is async and it is no longer safe to continue executing user code since failed async NCCL operations might result in subsequent CUDA operations running on corrupted data. Only one of these two environment variables should be set. backend (str or Backend, optional): The backend to use. Depending on build-time configurations, valid values are ``gloo`` and ``nccl``. By default uses the same backend as the global group. This field should be given as a lowercase string (e.g., ``"gloo"``), which can also be accessed via :class:`Backend` attributes (e.g., ``Backend.GLOO``). If ``None`` is passed in, the backend corresponding to the default process group will be used. Default is ``None``. pg_options (ProcessGroupOptions, optional): process group options specifying what additional options need to be passed in during the construction of specific process groups. i.e. for the ``nccl`` backend, ``is_high_priority_stream`` can be specified so that process group can pick up high priority cuda streams. Returns: The subgroup containing the current rank, and all the subgroups used for cleanup. Examples: >>> # Create two subgroups, where each has 2 processes. >>> # xdoctest: +SKIP("need process group init") >>> cur_subgroup, subgroups = dist.new_subgroups(ranks=[[0, 2], [1, 3]]) >>> rank = dist.get_rank() >>> tensor = torch.ones(1, device=rank) * rank >>> dist.all_reduce(tensor, group=cur_subgroup) >>> tensor tensor([2]) # Subgroup 0: ranks 0 and 2 tensor([4]) # Subgroup 1: ranks 1 and 3 Nrz1The arg 'ranks_per_subgroup_list' cannot be emptyrzRank z has appeared in both subgroup z and r)rrvrGrr9rr) Zranks_per_subgroup_listrrr4rrZrank_to_ranks_dictrrrrr\r\r]rIs0L )rrrecs~t|dkr*|ds*|ds*d|}tj|gD]@}|t|krNq8t|tfdd|D}|r8|Sq8dS)NrrErFc3s|]}|kVqdSrfr\)rrrr\r]rsz,_find_pg_by_ranks_and_tag..)rrTrrr0r rUr)rrr;Zgoodr\rr]rHs   rH)rrstriderecCst||dks*tdt|d|dt}d}|t|krZ|}||kstdnBtdt||D] }||||}||krj|}qj|dk std|t||}|dk r|S|dkrtdt||dS) NrzRanks length (z) must be divisible by stride (rz(rankset doesn't include the current noder2z-Cannot automatically create PG with empty tag)rQ) rrr9copyr?sortrHrvr)rrrrZmy_ranksr:Zrank_setrr\r\r]#_find_or_create_pg_by_ranks_and_tags$*  r)rrecCs$tj|}|dr |dd}|S)z1 Returns the tag associated with ``pg``. rFN)rrrT)rrr\r\r]_get_group_tags   rcCs tj|Srf)rrrr\r\r]_get_process_group_namesr)N)N)N)N)N)N)Nr)NNr)Nr)NNr)NNF)NFr)NF)NF)N)NrN)rNN)rN)NF)NF)NF)NF)NrNF)NrNF)NNNF)NF)N)rcollections.abc collections contextlibrrloggingr&picklerrrdatetimertypingrrrrrr r rZtorch._C._distributed_c10dr r r rrrrrrrrrrrrrr constantsrZ c10d_loggerrrr!r __all__r r!r"r#Picklerr Unpicklerrr^r_rZ ImportErrorr`rarbrc getLoggerrrrboolrRr"r#rrVr%rrrurrrrrrrrrrr[rr;r$r@rrrrrrSrTrrUr rrabcIterablerrrrr@rBr>rDrAr?rCr)rr-r.r7r8r<r=r4r9r:rrEr=rQrJr^racontextmanagerrrlr0r2r1ZSUMr,r*r+rLrKr(rrr)r6r3rPr&rWrr'rr5rOrNrMrXrr.r-rr/rFrOr<rrGrrHrIrHrrrZ'dynamo_unsupported_distributed_c10d_opsr\r\r\r]s  $L             xB" zC/           @ 7P $$'"&, X;;)<O> =, K [mm lIX V 6_ E)T v,H  K i  i