[Thg@%SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKJr SSKJr SSKJrJrJrJrJr SSKJr SSKrSSKJr SSKJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3 SS K4J5r5 SS K6J7r7 SS K8J9r9J:r: SS K;Jr>J?r? S SK@JArAJBrB S SKCJDrDJCrC /SQrESrFSrGSrHSrISrJ\ RrL\ RrNSSjrO\O"5 SSKJPrP S\PlQ\ES/- rESSKJSrS S\SlQ\ES/- rESSKJTrTJUrU S\UlQ\ES/- rESSKJVrV S\VlQ\ES/- rESSKJWrW S\WlQ\ES /- rE\R"\Y5rZS!r[S"\.S\\4S#jr]"S$S%\^5r_"S&S'5r`"S(S)5ra\a"5rb"S*S+5rc"S,S-5rd0qe\f\-\g\^\244\hS.'0qi\f\-\^4\hS/'0qj\f\-\f\k\k44\hS0'0ql\f\-\^4\hS1'Sqm0qn\f\^\o\-4\hS2'0qp\f\-\^4\hS3'Sqq\\^\hS4'"S5S65rr\r"5qs"S7S8\t5ru"S9S:\uS;9rv"S<S=\uS;9rwS>\_S\4S?jrxS@\SS4SAjrySqz\\^\hSB'SCr{SS:\\-S\^4SDjjr|SS:\\-S\R4SEjjr~SS:\\-S\o\^4SFjjr\?\"SGSH94SSIjj5rS:\\-S\\4SJjrSSKjrS:\-SL\kS\k4SMjrS:\-SN\kS\k4SOjr\"SP\SQ9S\k4SRj5rS:\-S\o\k4SSjrS\k4STjrSU\^S\k4SVjrSW\o\kSX\^S\^4SYjrSSZjrSS[jrSS:\\-S\-4S\jjrSS:\-SL\\kSN\\kS]\\S\k4 S^jjrS:\-S_\kS`\^4SajrS\GR GR"4SbjrSScjrSSdjrSSejrS\\4SfjrS\\4SgjrS\\4ShjrS\\4SijrS\\4SjjrS>\^S\\4SkjrS\\4SljrS\\4SmjrS\k4SnjrS\-4SojrS\24SpjrSSqjrSS:\\-S\^4SrjjrSS:\\-S\_4SsjjrSt\\^\R4S\^4SujrSv\-S\k4SwjrSS:\\-S\f\^\44SxjjrS\o\f\^\44SyjrS\k4SzjrSS{\\kS\k4S|jjrS@\SS4S}jrSS@\S:\\-SS4S~jjr\>\?SS>\\^S\\^S@\\S\kS_\kS\\2SU\^S\\S\\RSS4Sjj55rSrSSjrSS:\\-4SjjrSS:\\-4SjjrSS:\\-S\k4SjjrSS:\\-S\k4SjjrSS\GRfS\\kS:\\-SX\kS\\kS\\34 SjjrSS\GRfS\\kS:\\-SX\kS\\kS\\34 Sjjr\>SS\GRfS\\kS:\\-SX\kS\\kSS4 Sjj5r\>SS\GRfS\\kS:\\-SX\kS\\kS\k4 Sjj5r"SS\35r"SS5r\GRtSS:\\-St\\RS\\\4Sjj5rS\o\cS\o\34Sjr\>SS\GRfS\\kS:\\-S\\S\\k4 Sjj5r\>\.GR|SS4Sj5r\>\"S\SQ9\.GR|SS4Sj55r\>S\.GR|SSS4S\GRfS\\kS:\\-S\\S\\k4 Sjj5rSrSr\>SSj5r\>SS\S\\o\S\\kS:\\-S\\k4 Sjj5r\>SS\o\S\\kS:\\-St\\RS\\k4 Sjj5r\>SS\o\S\\kS:\\-St\\RS\\k4 Sjj5r\>SS\o\S\\kS:\\-St\\RS\\k4 Sjj5r\>SS\o\S\\o\S\\kS:\\-S\\k4 Sjj5r\>SSj5r\>SSj5r\>\"S\SQ9SSj55r\>\"S\SQ9SSj55rSr\>SS\GRfS\\o\GRfS\\kS:\\-S\\S\\k4 Sjj5r\>SS\GRfS\\o\GRfS\\kS:\\-S\\S\\k4 Sjj5r\>\.GR|SS4Sj5r\>\.GR|SS4Sj5r\"S\SQ9\.GR|SS4Sj5r\>SSj5r\>SSj5r\>\wGRSS4S:\\-4Sjj5r\wGRSS4S:\\-4Sjjr\B4S\GRGRRS\^S\2S_\kS\kS@\4 SjjrSW\o\kS\^4SjrSW\o\kS\k4SjrSrSS>\\^S\_4SjjrS\\4Sjr\?SS\\-S\\oS@\\S\\S\\^S\\-4 Sjj5r\?SS\\R4Sjj5rSS\\R4SjjrSSjrSSjrSX\^SW\o\kS\\-4SjrSX\^SW\o\kS\kS\-4SjrSv\-S\^4SjrSv\-S\^4SjrSv\-S\24Sjrg!\Ra SrFG Nf=f!\Ra SrGG Nf=f!\Ra SrHG Nf=f!\Ra SrIG N f=f!\Ra SrJG Nf=f)z,Distributed Collective Communication (c10d).N) namedtuple) timedelta)AnyCallableOptional TYPE_CHECKINGUnion) deprecated)_DistStoreError)_DistributedBackendOptions_register_process_group_resolve_process_group_unregister_all_process_groups_unregister_process_groupAllgatherOptionsAllreduceCoalescedOptionsAllreduceOptionsAllToAllOptionsBarrierOptionsBroadcastOptions DebugLevel GatherOptionsget_debug_level PrefixStore ProcessGroupReduceOp ReduceOptionsReduceScatterOptionsScatterOptionsStoreWork)+set_pytorch_distributed_envs_from_justknobs) _WaitCounter)handle_torch_functionhas_torch_function)not_none)_exception_logger _time_logger)default_pg_nccl_timeoutdefault_pg_timeout)register_rendezvous_handler rendezvous)JBackend BackendConfig GroupMemberP2POp all_gatherall_gather_coalescedall_gather_object all_reduceall_reduce_coalesced all_to_allall_to_all_singlebarrierbatch_isend_irecv broadcastsend_object_listrecv_object_listbroadcast_object_listdestroy_process_groupgather gather_objectget_backend_config get_backendget_default_backend_for_deviceget_rankget_world_size get_pg_countgroupinit_process_groupirecvis_gloo_availableis_initializedis_mpi_availableis_backend_availableis_nccl_availableis_torchelastic_launchedis_ucc_availableis_xccl_availableisendmonitored_barrier new_group new_subgroupsnew_subgroups_by_enumerationrecvreducereduce_scatterscatterscatter_object_listsendsupports_complexrrrrrrrrrrrrr rrr!r+get_group_rankget_global_rankget_process_group_ranks reduce_opall_gather_into_tensorreduce_scatter_tensorget_node_local_rank split_groupTreturnc[[[[[[ [ [[[[[[[[[/nUH nSUlM g)N"torch.distributed.distributed_c10d)rrrrrrrrrrrrr rrr! __module__)_public_types_to_change_moduletypes Z/var/www/auris/envauris/lib/python3.13/site-packages/torch/distributed/distributed_c10d.py_export_c_typesrnsM!  !&"$/>/)ProcessGroupMPIrirpF)ProcessGroupNCCLrq)_ProcessGroupWrapperProcessGroupGloors)ProcessGroupUCCrt)ProcessGroupXCCLru pg_wrapperreduceOpc[R[R[R[R[R [R /nX;$)z8Return true if reduce ops is supported. False otherwise.)rMAXMINPRODUCTBANDBORBXOR)rwdenyLists rmr^r^sB      H  ##roc N\rSrSr%SrSrSrSrSrSr Sr \ "S S S /5r 0r \\\ 4\S '\\\\ \\ /r\\\ S .r\\\4\S'\SS/\S/\ S/\SS/\ SS/0r\\\\4\S'\\R,R \\R,R \\R,R\ \R,R\\R,R\ \R,R0r\\\R,4\S'S\4Sjr\SS\\\\\4SS4Sjj5rSrg)r.a An enum-like class for backends. Available backends: GLOO, NCCL, UCC, MPI, XCCL, and other registered backends. The values of this class are lowercase strings, e.g., ``"gloo"``. They can be accessed as attributes, e.g., ``Backend.NCCL``. This class can be directly called to parse the string, e.g., ``Backend(backend_str)`` will check if ``backend_str`` is valid, and return the parsed lowercase string if so. It also accepts uppercase strings, e.g., ``Backend("GLOO")`` returns ``"gloo"``. .. note:: The entry ``Backend.UNDEFINED`` is present but only used as initial value of some fields. Users should neither use it directly nor assume its existence. undefinedgloonccluccmpixccl_BackendPlugin creator_fn extended_api_pluginscpucudaxpudefault_device_backend_maprrrbackend_capabilitybackend_type_mapnamec[U[5(d [S5e[[UR 5[R 5nU[R :XaUR5nU$).Create and return a new instance of the class.z0Backend constructor parameter must be string-ish) isinstancestr ValueErrorgetattrr.upper UNDEFINEDlower)clsrvalues rm__new__Backend.__new__$sS$$$OP Pw/@/@A G%% %JJLE roNdevicesrgc[[UR55(d-[[UR5UR 55 UR 5[R ;a-[R R UR 55 Ub:UH4nUS:wdM US:wdMUR 5[RU'M6 [RR[RUR 5'Uc>[R"SUS35 SS/[RUR 5'OY[U[ 5(a#U/[RUR 5'O!U[RUR 5'[R#X#5[R$UR5'g)a Register a new backend with the given name and instantiating function. This class method is used by 3rd party ``ProcessGroup`` extension to register new backends. Args: name (str): Backend name of the ``ProcessGroup`` extension. It should match the one in ``init_process_group()``. func (function): Function handler that instantiates the backend. The function should be implemented in the backend extension and takes four arguments, including ``store``, ``rank``, ``world_size``, and ``timeout``. extended_api (bool, optional): Whether the backend supports extended argument structure. Default: ``False``. If set to ``True``, the backend will get an instance of ``c10d::DistributedBackendOptions``, and a process group options object as defined by the backend implementation. device (str or list of str, optional): device type this backend supports, e.g. "cpu", "cuda", etc. If `None`, assuming both "cpu" and "cuda" .. note:: This support of 3rd party backend is experimental and subject to change. NrrDevice capability of zl unspecified, assuming `cpu` and `cuda`. Please specify it via the `devices` argument of `register_backend`.)hasattrr.rsetattrr backend_listappendrr BackendTypeCUSTOMrwarningswarnrrrrr)rrfuncrrdevices rmregister_backendBackend.register_backend.sTBw -- GTZZ\4::< 8 ::"2>1I1I1P1P  . ? MM'v.&&  9>vG & &tzz| 4  % %8?yG & &tzz| 47>G & &tzz| 4)0)?)?)S&ro)FN)__name__rj __qualname____firstlineno____doc__rGLOONCCLUCCMPIXCCLrrrdictr__annotations__rrrlistrrrr classmethodrr r__static_attributes__rrormr.r.s$I D D C C D 0<2PQN*,Hd3&',tT4c:L2S#X ufo vh ug eV_ eV_ 0S$s)^, <++55 l&&++ l&&++ l&&++ \ % % ) ) \ % % ) ) =d3 8 8893 37 ;T %T#Y/0 ;T  ;T;Tror.cD\rSrSrSrS\4SjrSrS\\ \44Sjr Sr g ) r/imzBackend configuration class.backendc  0Ul[U5nU[R:XaV[R R 5Rn[RUn[U5URU'GOJUR5[R;aG[RUR5n[U5n[RXE5UlOSUR5;aSUS3nUR5R!S5HsnUR!S5n[#U5S:wa[S US U35eUupXR;a[S U S US U35e[U5URU 'Mu O0[$R&"S US35 [U5nUUUS.Ul[(R+SUR5 g![a [SUS35Sef=f)Init.zWe detected accelerator z on your machine. But we don't know which communication backend to use for this accelerator. Please specify the `backend` argument in the `init_process_group` call.N: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.rzUsing backend config: %s)device_backend_maprr.rtorch_C_get_acceleratorrlrKeyErrorrrrrrfromkeyssplitlenrrloggerinfo) selfr device_type backend_strsupported_devices backend_valbackend_str_error_messagedevice_backend_pair_strdevice_backend_pairrs rm__init__BackendConfig.__init__ps"68g, g'' ' ((335::K %@@M 7>{7K'' 4]]_ 4 4 4!( : :7==? K !'*K&*mm4E&SD # GMMO # -\\c[ded)g % ,3==?+@+@+E'&=&C&CC&H#*+q0$&&=%>bAZ@[]#6444$0999@ D]C^`3:'2B''/,F$ MM'y1--  "'*K"#"'D #  .0G0GHi  .{m<^_  s +G((HcbSRSURR555$)z8Return all the device:backend pairs separated by commas.rc34# UHupUSU3v M g7f)rNr).0rrs rm )BackendConfig.__repr__..s! 9Xofvhay !9Xs)joinritemsrs rm__repr__BackendConfig.__repr__s/xx 9=9P9P9V9V9X   rorgcUR$)z!Return backend map of the device.rrs rmget_device_backend_map$BackendConfig.get_device_backend_map&&&rorN) rrjrrrr.rrrrrrrrormr/r/ms0&@I@ID 'S'\(:'ror/c<\rSrSrSrS Sjr\"S\S9S5rSr g) _reduce_opiz Deprecated enum-like class. For reduction operations: ``SUM``, ``PRODUCT``, ``MIN``, and ``MAX``. :class:`~torch.distributed.ReduceOp` is recommended to use instead. Nc[RRR5Hup[ XU5 M [RRUlgN)r RedOpType __members__rr)rkvs rmr_reduce_op.__init__sA&&2288:DA DQ ;#--99roz\`torch.distributed.reduce_op` is deprecated, please use `torch.distributed.ReduceOp` insteadcategoryc,[RX5$r)object__getattribute__)rkeys rmr_reduce_op.__getattribute__s &&t11ro)rrgN) rrjrrrrr FutureWarningrrrrormrrs-:  : 2  2rorc^\rSrSrSrS S\S\RS\\ S\\ S\ S\\ 4 S jjr S S\S\RS\\ S\\ S\ S\\ 4 S jjr U4S jr S rU=r$)r1ia' 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, optional): 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. group_peer (int, optional): Destination or source rank. optensorpeerrHtag group_peercXlX l[U5Ul[ URX6SS9UlXPl[ URX65Ulg)rT return_globalN)rr_group_or_default_grouprH_canonicalize_group_rankrrr)rrrrrHrrs rmrP2POp.__init__sJ ,U3 , JJ  24::tProcZ[U5 [US5 [RU5$)rr) _check_op_check_single_tensorrr)rrrrrHrrs rmr P2POp.__new__s$ " VX.~~c""roc >[UR5nURRnUR(aURROSnSU;aUnUR nO#SU;aUR nUnO[ TU]5$SUSUSUSUSURRS URRS 3 $) N default_pgr]rXzP2POp(z pg=z , group_src=z , group_dst=z, z, )) rErHrr group_namersuperrrshapedtype)r my_group_rankop_namersd __class__s rmrP2POp.__repr__s , ''"".2jjTZZ**l W AA w AA7#% %yZL QC|A3cRVR]R]RcRcQddfgkgrgrgxgxfyyz{{ro)rHrrrrrNNrN)rrjrrrrrTensorrintrrrrr __classcell__)rs@rmr1r1s.#(,$(Q Q Qsm Q  % Q  QSMQ.#(,$( #  #  #sm #  % #  #SM # | |ror1c z\rSrSrSrS S\S\RS\\RS\\ S\\ 4 S jjr S r g) _CollOpiax 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_tensorredoprootc@XlX lX0lX@lXPlgr)rrrrr )rrrrrr s rmr_CollOp.__init__*s $  ro)rrrr r)NNN) rrjrrrrrrrrrrrrrormrrsb .2$("     U\\*  !  sm  ror_pg_map _pg_names_pg_group_ranks_pg_backend_config _tags_to_pg _pg_to_tag_backendc\rSrSrSrSSjr\S\\4Sj5r \ RSSj5r \S\ \\ \ \444Sj5r\S\ \\ 44S j5r\S\ \\ \\444S j5r\S\ \\ 44S j5r\S\4S j5r\RS \SS4Sj5r\S\ \ \\44Sj5r\S\ \\ 44Sj5r\S\ \\\44Sj5r\S\\ \ \44Sj5rSrg)_WorldiFz 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.. rgNc SUl0Ulgr _default_pg_pg_coalesce_staters rmr_World.__init__PsEGrocUR$)z Process group that includes all ranks of the cluster. This default ProcessGroup is used by c10d APIs when a ProcessGroup is needed but None is provided. r.rs rmr _World.default_pgTsrocXlgrr2rrs rmr r3^s roc[$)z Provide Mapping from ProcessGroup to backend name and store. 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 )r#rs rmpg_map _World.pg_mapbs roc[$)zj Process group's names, map from ProcessGroup to str. TODO don't expose the map, expose fine grained ops )r$rs rmpg_names_World.pg_namesos roc[$)zh Process group's global rank to local rank mapping. TODO don't expose the map, expose fine grained ops )r%rs rmpg_group_ranks_World.pg_group_ranksys roc[$)zU Process group's backend config. TODO don't expose the map, expose fine grained ops )r&rs rmpg_backend_config_World.pg_backend_configs "!roc[$)zd Process group count for default naming. TODO don't expose group_count, use something else instead  _group_countrs rm group_count_World.group_counts rorcUqg)zKUse to compute the name of ProcessGroups when using global synchronization.NrCr5s rmrErFs  roc[$r)r'rs rm tags_to_pg_World.tags_to_pgs roc[$r)r(rs rm pg_to_tag_World.pg_to_tags rocUR$r)r/rs rmpg_coalesce_state_World.pg_coalesce_staterroc n/n[S5nURR5HnURUnUR UR UUR URU[U5U:wa[UR55O/[U5URS.5 M U$)z| Return a list of dict with process groups and backends. Along with their unique IDs and configurations (types and ranks). N)pg_namepg_descbackend_configranks group_sizerE) _get_group_sizer7keysr=rr: group_descr@rrrE)r config_infodefault_pg_sizepgrUs rmpg_config_info_World.pg_config_infos-/ )$/++""$B''+E   #}}R0!}}&*&<&%A B"4 c(9#:""S Dd<&8!894 c 12'4 d7m(C#D''T#s(^ 4ror+ch\rSrSrSr\S\\4Sj5r\RS\\4Sj5rSr g) _WorldMetaiza Meta class of ``group`` and ``GroupMember``. Allows them to have the class property ``WORLD``. rgc"[R$r_worldr )rs rmWORLD_WorldMeta.WORLDs   ror\cU[lgrre)rr\s rmrgrhs rorN) rrjrrrr_rrrgr`rrrormrcrcsK!h|,!! \\x -rorcc\rSrSrSrSrg)rHizGroup class. Placeholder.rN)rrjrrrrrrormrHrHs#rorH) metaclassc\rSrSrSrSrSrg)r0izGroup member class.irN)rrjrrrNON_GROUP_MEMBERrrrormr0r0s ror0rcU[R:Xa;[[[5(d[ R "S5 [$[$[$)NzSAttempted to get default timeout for nccl backend, but NCCL support is not compiled)r.rrr*rrrr+rs rm_get_default_timeoutrpsA',,19== MMe & %&&!!rotimeoutcJ[U[5(d[SU35eg)Nz@Expected timeout argument to be of type datetime.timedelta, got )rr TypeErrorrqs rm_check_valid_timeoutrus+ gy ) )Nwi X   *ro_default_pg_init_methodstore_based_barrier_keycU=(d [5n[U[5(dQ[R"S[ U5S35 [U[ 5(ag[S[ U5S35eURn[U5S:XaUSR $[U5S:Xag[R"S5U;agUSR $)a .. note:: This is an internal helper and does not have backward compatibility, please use with caution. Return the device type to use with ``group`` for object collectives or 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: str: The device type to use for object collective with ``group``. You are using a Backend w as a ProcessGroup. This usage is deprecated since PyTorch 2.0. Please use a public API of PyTorch Distributed instead.rz$Expecting a ProcessGroup, but got a .r'r) _get_default_grouprrrrrlrsr _device_typesrrr)rHrs rm_get_object_coll_devicer~s.  )')E e\ * * &tE{m4. .  e- . .CDK=PQRS S !!G 7|qqz W  e  'qzroc[R"S5 U=(d [5n[U[5(d=[R"S[ U5S3[ SS9 [R"S5$URn[U5S:XaUS$[U5S:Xa [S 5e[R"S5U;a[R"S5nOUSn[R"S US 35 U$) a .. note:: This method will be deprecated, it only stays for backward-compatiblity reason. Alternatives: - If you need to find a device for object collectives, please use `_get_object_coll_device(group)`. - If you need to query the device types supported by group, please use `_device_capability(group)`. Return the device type registered with ``group``. For example, if `init_process_group("nccl", ...)` was called, the returned value would be `torch.device("cuda")`. Errors out if no device has been registered. Args: group (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Returns: torch.device: The device type registered with ``group``. a`_get_pg_default_device` will be deprecated, it only stays for backward-compatiblity reason. If you need to find a device for object collectives, please use `_get_object_coll_device`. If you need to query the device types supported by group, please use `_device_capability(group)`. ryrz) stacklevelrr'rzXDefault device not found, because no backend has been registered with this ProcessGroup.zqMultiple backends are registered with this ProcessGroup. We cannot determine which one is the default. Returning z#. Please consider using other APIs.) rrr|rrrlrrrr}r RuntimeError)rHrrvs rm_get_pg_default_devicerAs4 MM (  )')E e\ * *  &tE{m4. .   ||E"" !!G 7|qqz W  &  << ' )e$BB  ==?DA0 0  roc~U=(d [5nURVs/sHoRPM sn$s snf)z Return the device type(s) supported by ``group``. Args: group (ProcessGroup, optional): The process group to query. If None, the default process group will be used. Returns: List[str]: A list of device types supported by ``group``. )r|r}rl)rHrs rm_device_capabilityrs4  )')E&+&9&9 :&9FKK&9 :: :s: secondsc[SU3nURUS5 [RSX`5 UnURUS5nUS3n X:XaUR U S5 [ U[ SUS- -S 95n[R"5n URU /U5 [RSUUU5 g![an URUS5n[RS [R"5U - UUUUUU 5 [ [R"5U - S 9U:a[S US US USUSUSU S3 5eSn A OSn A ff=fM)a Store based barrier for synchronizing processes. 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()``. rr'z#Added key: %s to store for rank: %srz :last_worker1rirzWaiting in store based barrier to initialize process group for %s secondsrank: %s, key: %s (world_size=%s, num_workers_joined=%s, timeout=%s error=%s)zDTimed out initializing process group in store based barrier on rank z , for key: z (world_size=z, num_workers_joined=z , timeout=z error=r Nz@Rank %s: Completed store-based barrier for key:%s with %s nodes.) STORE_BASED_BARRIER_PREFIXaddrdebugsetmaxrtimewaitrDistStoreErrorr) rankstorerrendezvous_countrqlogging_interval store_key world_size worker_countlast_worker_keystartes rm_store_based_barrierrs ..a |  !K? {:,.DUGL MMroz`torch.distributed.distributed_c10d._get_global_rank` is deprecated, please use `torch.distributed.distributed_c10d.get_global_rank` insteadrc[X5$)z1Use get_global_rank as this method is deprecated.)r`)rHrs rm_get_global_rankr*s 5 ''rocV[[RUR55$)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. )rrfr=rXrs rmrara4s# %%e,113 44rocU[RLdUc[5nUR5$UR5$)zGet a given group's world size.)r0rgr|sizerHr s rmrWrWAs5 !!!U]')   ::<rorc8[U5nUR5$r)rr)rrHs rm_get_group_size_by_namerIs ": .E ::<rorUrcL[X5nUc [S5eUR$N)_find_pg_by_ranks_and_tagrr)rUrrHs rm$_resolve_group_name_by_ranks_and_tagrNs) &c 1E }n   rocx[U[R5(d[SUS[ U5S35eg)z;Check that the parameter ``param_name`` is a single tensor./Invalid function argument. Expected parameter `z,` of type torch.Tensor but got instead.N)rrrrsrl)param param_names rmr r WsB eU\\ * *? |L5k]) /   +roc  [U[5(d[SUS[U5S35e[ SU55(d8[SUS[U5SUVs/sHn[U5PM snS35egs snf)z=Check that the parameter ``param_name`` is a list of tensors.rz2` of type List[torch.Tensor] but got rc3V# UHn[U[R5v M! g7fr)rrr)rps rmr%_check_tensor_list..gsLroc:U[[4;a [S5eg)z/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)rSrJr)rs rmrrs% % +   roc^[U[5(a[SU55(d [S5eUSRm[U4SjU55(d [S5eg)zl Check that the ``p2p_op_list`` is a list of P2POp instances. Also, check that all ops use the same group. c3B# UHn[U[5v M g7fr)rr1)rp2p_ops rmr%_check_p2p_op_list..s40;f 65!! szZInvalid ``p2p_op_list``. Each op is expected to to be of type ``torch.distributed.P2POp``.rc3B># UHnTUR:Hv M g7frr)rrrHs rmrrs?;u $;sz#All ops need to use the same group.N)rrrrrH) p2p_op_listrHs @rm_check_p2p_op_listrss k4 ( (40;411 9  N E ?;? ? ?>?? @roc[$)z&Check if the MPI backend is available.)_MPI_AVAILABLErrormrMrM roc[$)z'Check if the NCCL backend is available.)_NCCL_AVAILABLErrormrOrO roc[$)z'Check if the Gloo backend is available.)_GLOO_AVAILABLErrormrKrKrroc[$)z&Check if the UCC backend is available.)_UCC_AVAILABLErrormrQrQrroc[$)z'Check if the XCCL backend is available.)_XCCL_AVAILABLErrormrRrRrroc[[RSUR5S3S5nU(aU"5$UR5[R ;$)a& Check backend availability. 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_ _availableN)rr distributedrr.r)ravailable_funcs rmrNrNsLU..#gmmo5Fj0QSWXN ==?g22 22roc&[RSL$)z8Check if the default process group has been initialized.N)r0rgrrormrLrLs   D ((roc2[R"S5SL$)a Check 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.. TORCHELASTIC_RUN_IDN)osgetenvrrormrPrPs 99* +4 77rocB[[R"SS55$)NTORCH_DIST_INIT_BARRIER0)rrrrrorm_is_barrier_after_initrs ryy2C8 99roc[5(d [S5e[(a[[R 5$[R $)z    ;  $%J}}Z0A rocU[lUb$U[R:waUR 5OSn[ R RRU5 g)Nr) rfr r0rmrrr_distributed_c10d_set_global_rank)r\rs rm_update_default_pgr(sAF21M1M+M2779SUD HH//5rocU=(d [5n[U5(a [S5e[RR U5n[ [U55$)a} Return the backend configuration of the given process group. Args: group (ProcessGroup, optional): The process group to work on. The default is the general main process group. If another specific group is specified, the calling process must be part of :attr:`group`. Returns: The backend configuration of the given process group as a lower case string. Invalid process group specified)r|rrrfr@getrr&)rHr\rTs rmrBrB.sO  &$&B":;;--11"5N x' ((rocU=(d [5n[U5(a [S5eU[R;a[RUOSn[ [ U5S5$)aa Return the backend of the given process group. Args: group (ProcessGroup, optional): The process group to work on. The default is the general main process group. If another specific group is specified, the calling process must be part of :attr:`group`. Returns: The backend of the given process group as a lower case string. r Nr)r|rrrfr7r.r&)rHr\pg_stores rmrCrCBsY  &$&B":;;$&&--$7v}}R TH 8H%a( ))rorc[U[R5(a URnO [R"U5Rn[R R U5nUc[SU35eU$)z Return the default backend for the given device. Args: Union[str, torch.device]: The device to get the default backend for. Returns: The default backend for the given device as a lower case string. z,Default backend not registered for device : )rrrrlr.rr r)r device_strrs rmrDrDVse&%,,''[[ \\&).. 0044Z@GGxPQQ Nror\cSnUR[R"S55n[ 5(a![ U[ 5(a UR$g![a N=f=f)Nrr) _get_backendrrrrOrrquid)r\rs rm_get_process_group_uidrms\G //%,,v"67z'3CDD{{    s%A A'&A'cU=(d [5n[U5UR[U5[ U5[ U5S.$)z: Return the pg configuration of the given process group. )rRrSrTpg_sizerU)r|_get_process_group_namerYrBrWra)rHr\s rm_get_pg_configrxsC  &$&B*2.==,R0"2&(,  roc~[RR5Vs/sHn[U5PM nnU$s snf)z9 Return the pg configuration of all the process groups. )rfr7rXr)r\rZs rm_get_all_pg_configsrs@ &,]]%7%7%9)%9rr%9) )s:c"[R$)z' Return the number of process groups. )rfrErrormrGrGs   ro fallback_rankcS[R;a[[RS5$Ub [U5$[S5e)a Return the local rank of the current process relative to the node. Semantically, this is a useful concept for mapping processes to devices. For example, on a node with 8 accelerator you could use the node local rank to decide which accelerator device to bind the process to. In practice, the actual assignment of node local ranks is handled by the process launcher outside of pytorch, and communicated via the `LOCAL_RANK` environment variable. Torchrun will automatically populate `LOCAL_RANK`, but other launchers may not. If `LOCAL_RANK` is unspecified, this API will fall back to the provided kwarg 'fallback_rank' if specified, otherwise it will raise an error. The intent is to allow writing an application that runs either in single or multi device contexts without error. LOCAL_RANKzLOCAL_RANK is not in the environment. Consider passing fallback_rank to allow `get_node_local_rank` to work, assuming you are not running in a multi-device context and want the code to run locally instead.)renvironrr)rs rmreresH rzz!2::l+,,  "=!!  k rocZ[RR5HnURn[R "S5U;dM+UR [R "S55n[5(dMa[U[5(dMxURU5 M g)a This API adds an ephemeral timeout extension for all PGs locally on one rank. The timeout gets reset when the first collective issued after API called finished. NOTE: We only support to set timeout for cuda backends for now. NOTE: While this feature provides flexibility in specific scenarios, it introduces statefulness to timeout setting. Therefore, it is advisable to use this API sparingly and consider alternative approaches, such as directly setting the timeout or utilizing a barrier collective (one can set any timeout to the barrier), whenever feasible. Args: timeout (timedelta): The delta of timeout to extend. Returns: None. rN) rfr7rXr}rrrrOrrq_add_ephemeral_timeout)rqr\rrs rm"_add_ephemeral_timeout_for_all_pgsr sr&mm  """ << 7 *ooell6&:;G ""z';K'L'L..w7 #rochUc [5n[U5(a [S5e[U[5(deUR n[ 5n[R"S5U;aZ[5(aKUR[R"S55n[U[5(aURU5 [R"S5U;aUR[R"S55n[5(a'[U[5(aURU5 O5[5(a&[U[5(aURU5 [U5S:Xa[ R""S5 UHnUR%U5 M g)a Set the timeout for the given process group when users want to use a different timeout instead of default values. Args: timeout (timedelta): Timeout for operations executed against the process group which users want to set. Default value is 10 minutes for NCCL and 30 minutes for other backends. This is the duration after which collectives will be aborted asynchronously and the process will crash. 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. When TORCH_NCCL_BLOCKING_WAIT is set, the process will block and wait for this timeout. group (ProcessGroup, optional): The process group to work on. The default is the general main process group. If another specific group is specified, the calling process must be part of :attr:`group`. Returns: None Nr rrrz:Set timeout is now only supported for either nccl or gloo.)r|rrrrr}rrrrKrrsrrOrqrrr_set_default_timeout)rqrHrbackendsrs rm_set_pg_timeoutr$s9( }"$%  :;; e\ * ** *!!GuH ||Eg%*;*=*=$$U\\%%89 g/ 0 0 LL ! ||Fw&$$U\\&%9:   :g7G#H#H LL !  Z9I%J%J LL ! 8} RS$$W-ro init_methodrr pg_options device_idc ^^[Rb [S5e[5 S[R ;a([ RRR5 Ub UbS5eUbUS:dS5eUS:dS5eOUcSnUc,Ub)[RRUR5nUcS n[U5nUc [U5n[U5 [!/S S 9nU[R":XaOUS :wdUS :wa[$R&"S USUS35 [)S S /U[+5UUSS9up[-U 5 OaUc?[/[1U5XCUS9n [3U 5upTnUR5U5 [7SU5n[)UU/UUUUUUSS9 up[-U 5 [9[RR;55V s0sHn X_M sn [<R>[R'[<R@[1[R5Sq!Uq"[RFmS[I5S3mUU4Sjn U [l#[K5S:XaB[LROS5 U[R":Xa [Q5 g[SXEXcU5 ggs sn f)ag Initialize the default distributed process group. This will also initialize the distributed package. There are 2 main ways to initialize a process group: 1. Specify ``store``, ``rank``, and ``world_size`` explicitly. 2. Specify ``init_method`` (a URL string) which indicates where/how to discover peers. Optionally specify ``rank`` and ``world_size``, or encode all required parameters in the URL and omit them. If neither is specified, ``init_method`` is assumed to be "env://". Args: backend (str or Backend, optional): The backend to use. Depending on build-time configurations, valid values include ``mpi``, ``gloo``, ``nccl``, ``ucc``, or one that is registered by a third-party plugin. Since 2.6, if ``backend`` is not provided, c10d will use a backend registered for the device type indicated by the `device_id` kwarg (if provided). The known default registrations today are: ``nccl`` for ``cuda``, ``gloo`` for ``cpu``. If neither ``backend`` nor ``device_id`` is provided, c10d will detect the accelerator on the run-time machine and use a backend registered for that detected accelerator (or ``cpu``). This field can be given as a lowercase string (e.g., ``"gloo"``), which can also be accessed via :class:`Backend` attributes (e.g., ``Backend.GLOO``). If using multiple processes per machine with ``nccl`` backend, each process must have exclusive access to every GPU it uses, as sharing GPUs between processes can result in deadlock or NCCL invalid usage. ``ucc`` backend is experimental. init_method (str, optional): URL specifying how to initialize the process group. Default is "env://" if no ``init_method`` or ``store`` is specified. Mutually exclusive with ``store``. world_size (int, optional): Number of processes participating in the job. Required if ``store`` is specified. rank (int, optional): Rank of the current process (it should be a number between 0 and ``world_size``-1). Required if ``store`` is specified. store(Store, optional): Key/value store accessible to all workers, used to exchange connection/address information. Mutually exclusive with ``init_method``. timeout (timedelta, optional): Timeout for operations executed against the process group. Default value is 10 minutes for NCCL and 30 minutes for other backends. This is the duration after which collectives will be aborted asynchronously and the process will crash. 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. When TORCH_NCCL_BLOCKING_WAIT is set, the process will block and wait for this timeout. group_name (str, optional, deprecated): Group name. This argument is ignored pg_options (ProcessGroupOptions, optional): process group options specifying what additional options need to be passed in during the construction of specific process groups. As of now, the only options we support is ``ProcessGroupNCCL.Options`` for the ``nccl`` backend, ``is_high_priority_stream`` can be specified so that the nccl backend can pick up high priority cuda streams when there're compute kernels waiting. For other availble options to config nccl, See https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/api/types.html#ncclconfig-t device_id (torch.device, optional): a single, specific device to "bind" this process to, allowing for backend-specific optimizations. Currently this has two effects, only under NCCL: the communicator is immediately formed (calling ``ncclCommInit*`` immediately rather than the normal lazy call) and sub-groups will use ``ncclCommSplit`` when possible to avoid unnecessary overhead of group creation. If you want to know NCCL initialization error early, you can also use this field. .. note:: To enable ``backend == Backend.MPI``, PyTorch needs to be built from source on a system that supports MPI. .. note:: Support for multiple backends is experimental. Currently when no backend is specified, both ``gloo`` and ``nccl`` backends will be created. The ``gloo`` backend will be used for collectives with CPU tensors and the ``nccl`` backend will be used for collectives with CUDA tensors. A custom backend can be specified by passing in a string with format ":,:", e.g. "cpu:gloo,cuda:custom_backend". Nz5trying to initialize the default process group twice!z torch._dynamoz*Cannot specify both init_method and store.rz*world_size must be positive if using storez(rank must be non-negative if using storezenv://rFuse_hashed_namerzFor MPI backend, world_size (z ) and rank (z9) are ignored since they are assigned by the MPI runtime.r )rqrYrt)backend_optionsrqr'rYz[rank]c>[Rn[R"5=[lnT"U6 U[lUR 5nSR U4SjUR S555n[RRU5 [RR5 g!U[lf=f)N c3@># UHoS:waTSU3OSv M g7f)rz: Nr)rrexcepthook_prefixs rmrFinit_process_group.._distributed_excepthook..s* DSq7 !A3 ' :Os) sysstderrioStringIOgetvaluerrwriteflush)args old_stderrbufmsgr0old_hooks rm_distributed_excepthook3init_process_group.._distributed_excepthooksZZ ;;=( S $ dO#CJllnii DGIIdO     $CJs B;; Cr'VPerforming barrier after ProcessGroup initialization since TORCH_DIST_INIT_BARRIER = 1)*r0rgrr"r2modulesr_dynamo trace_rulesclear_lru_cacher.rr rlrpru_process_group_namerrr_new_process_group_helperr rr-r&next set_timeoutrrangerrfr=r7r)rv excepthookrErrrr9r)rr%rqrrrrr&r'r rrendezvous_iteratorir>r0r=s @@rmrIrIsJ$PQQ/1#++% !!113 M{24 3 A~KKK~qyDDDy   904488H gG&w/! %R?J'++  trz MM/ |<vN  2     G #   :& =",%t# '++>&? #E   g & e4E1      &#   :&{((--/000A 00F+++,}}Xk&7&789!J Z:: /j5IJJ**  /j5IJJ    s%C CCc U[RR5;a [S5eU b(U RbU R S:Xa [S5e[ U5 US;a*[X5n U (a[RU upX4$U cSOU n [U5S:Hn[5(a-[5R(a[[55nOSnU(dZ[5R5nUU;a<U(a#UR[5R5 [ R"S4$[%US3U5n ['U UU5n[)U5nS [+U5;aS [+U5;aU[,R.;d S U35eU[,R0:Xa[,R2UR55R5;a+UR7[&R8R25 GOiUR7[&R8R:5 GO>UR7[,R.U5 GO[,R2UR<R5;a*UR7[&R8R25 O[,R>RA5(ax[C[E[,R>RA555nUUR<R5;a)UR7[&R8RF5 O)UR7[&R8R:5 U (aU Ul UR55RI5GH~unn[%US3U 5nU[,RJ:Xa[M5(d [OS 5e[PRR"U5n[&R8RJnU(d[ R"S4s $UR5S :XaNURU5S :Xa:['UUR5URU55nUR7U5 GOU[,R::Xa'[WUXUS9n[&R8R:nGOmU[,R2:Xa[Y5(d [OS5eUbM[[U[\R^5(dS5eUR`U:wa[bRd"S5 O[\R^"5nSUl3Xvl0U(aXl4[kU5Ul6X&l7XVl8[]UXU5n[&R8R2nGO{U[,Rr:Xa6[u5(a'[wUXUS9n[&R8RrnGO1U[,Rx:XaA[{5(d [OS5e[}UX5n[&R8RxnOUR5[,R>;dSUR535e[,R>UR5nURnURn[&R8RFnU(d U"UXU5nO=[5nUUlCUUlDUUlEUUlFUUlGUUl7U"UU5nU[,R::Xa([[U[V5(deUR5 O;U[,R2:Xa'[[U[\5(deUR5 [[ U5[&5(aUn GONU[,R:[,R2[,Rr4;d"UR5[,R>;aK[5[R:Xa/[(d[RS5 O[UUUUUUS9n[[UR55R555S:XaNUR55RA5H*nUR[R"U5UU5 M, O,UR[R"U5UU5 GM UceU ceURU5 URU 5 U (aBURU 5R(a"URU 5nURU 5 X=4[RU'U[RU'[UU5 [+U5[RU'US;a5SU3n[RRS/5RU5 OSU3n[RRU/5RU5 U[RU'UU 4$)aH 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 nameNrzKinit_process_group device_id parameter must be an accelerator with an indexrrr/rrzUnknown backend type zDistributed package doesn't have MPI built in. MPI is only included if you build PyTorch from source on a host that has MPI installed.rrtz.Distributed package doesn't have NCCL built inzHExpected backend_options argument to be of type ProcessGroupNCCL.Optionszlbackend_options._timeout was specified, but timeout kwarg has a default value that will always override it. Fz.Distributed package doesn't have XCCL built inzUnknown 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.)rP store_prefixrrrrqr'ptd:ruser:)`rfr:valuesrindexrlrurr7rrLr|rNrRrperform_nocolor_splitr0rmrrr/rr.rrrr_set_default_backendrrrrrXrGiterrrrrMrrpcreaterrsrOrrqOptions_timeoutrris_high_priority_streamrQ_process_group_color split_colorglobal_ranks_in_grouprrrQrtrrRrurrrr rrrVrqgroup_id_set_sequence_number_for_group issubclassrrDETAILrrr_create_process_group_wrapperr_register_backendrr_set_group_name_set_group_descrrOeager_connect_single_devicer r@rI setdefaultrrL)rVrrcrrrr+rqpg_tagr'rYexisting_groupr prefix_storeis_default_grouprQrr\rTcustom_backendrrbackend_prefix_store backend_class backend_typebackend_pluginrrdist_backend_opts eager_backends rmrFrF s0V__++-- 9  )//"9Y^^u=T Y  ! Z26Q $mmN;OA!/ / * 2 J01Q6.0@@&'9';<   (*//1 3 3001C1E1U1UV//5 5*Q/7L$B #7+N #g,3c'l#:'222U6KG94UU2 g'' '||~DDFMMOO'' (@(@(E(EF'' (@(@(E(EF  # #G$<$<<CCE E  # #L$<$<$A$A B    " " $ $!$w'7'7'<'<'>"?@N!B!B!I!I!KK'' (@(@(G(GH  # #L$<$<$A$A B&-DDFLLN  +fXQ<F '++ %#%%"@ ,223HIM'3377L "33T99wwyB2779?!(!&&(!&&( '' 5 GLL (-$jgM(3388L GLL ($&&"#STT*!/3C3K3KLL^L#++w6MM_ #3":":"<:?7'. $-7*.B)/+5J 1)3 &,$joM(3388L GKK ',<,>,> ,$jgM(3377L GLL ($&&"#STT,$jM(3388L$$&'*:*:: ,[->->-@,AB :%--k.?.?.ABN'22J)66L'33::L *(*'! %?$@!*>!'/9!,/9!,,3!)-7!*:O!7 *+> >>  8 8 : GLL (m-=>> >>  8 8 : d=)< 8 8B  GLL',, D D  "g&6&66 J$5$55&KKR%B#0%/2'#- ' %M s>88:AACD E J(??AFFH$$U\\&%9<WI  U\\&1<Om Or  !! !  !! !z"z"R__Y/BB 2 11)<!/FMM"$FOOBJ+#&~#6FR   |$$$R,33B7!   ,33B7!FR | rocDU[R:XagUc[RnOUnUce[RR US5c [ S5e[U5[:Xa%UR5(aUR5 UbU[R:XGa$[[RSSS9HnUR5 M [S5 [RR5 [RR5 [R R5 [R"R5 [R$R5 [R&R5 [R(R5 [+5 S[lgUR5 [RU [RU [R U [R"U U[R(R/5;a'[0R2"S5 [R(U [R$R U5n[R$U Ub[[R&UR5U5 UR7S5(a"[R&S R5U5 [;UR<5 g![8a N"f=f) a] 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 c([RU$rrfr:xs rm'destroy_process_group..U 6??1+=roTrreverserzfSome coalesced collectives haven't been launched when ProcessGroup is destroyed. They will be cleaned.rVr)r0rmrgrfr7r rrlr _has_hooks_wait_for_pending_workssortedr:shutdownrclearr=r@rLrIrOrrErXrrremove startswith Exceptionrr)rHr\pg_to_shutdownrs rmr?r?.sS ,,, }     >> }}T"*:;; Bx<BMMOO ""$ }!2!22% OO!=t N  # # % 4  ##%  &&( !  &&(&( MM"  OOB   ! !" %  $ $R ( ))..0 0 MMC ((,""2&   R ? !!#&--b1>>&))%%b)004 ""--0  s"AL LLcU[R:XagU=(d [RnUce[RR US5c [ S5eUR[R"S55nUbU[R:XGa[5(a%[U[5(aUR5 [[R SSS9HnUR#5 M [5(a%[U[5(aUR%5 ['S5 [RR)5 [R R)5 [R*R)5 [R,R)5 [R.R)5 [R0R)5 [R2R)5 [55 S[lgUR#5 [RU [R U [R*U [R,U U[R2R95;a'[:R<"S5 [R2U [R.R U5n[R.U Ub[[R0UR?U5 URAS 5(a"[R0S R?U5 [EURF5 g![a SnGNf=f![Ba N5f=f) a Abort a given process group. If group.WORLD (i.e. `None`) is given, all process groups including the default one will be aborted. Args: group (ProcessGroup, optional): The process group to be aborted. .. note:: this API is experimental and currently only works with the NCCL backend. .. note:: this API should be used with `TORCH_NCCL_ASYNC_ERROR_HANDLING` turned off (i.e. set to 0). Otherwise, ProcessGroupNCCL's watchdog may automatically handle errors or timeouts for you including aborting the ProcessGroup. Nz6Invalid process group specified or has been destroyed.rc([RU$rr{r|s rmr~&_abort_process_group..rroTrrzdSome coalesced collectives haven't been launched when ProcessGroup is aborted. They will be cleaned.rVr)$r0rmrgrfr7r rrrrrrOrrq _group_startrr:abort _group_endrrr=r@rLrIrOrrErXrrrrrrr)rHr\r pg_to_abortrs rm_abort_process_grouprs$ ,,,  #+##B >> }}T"*QRR//%,,v"67 }!2!22   :g7G#H#H  "! OO!=t K        :g7G#H#H    4  ##%  &&( !  &&(&(  MM"  OOB   ! !" %  $ $R ( ))..0 0 MMA ((,""2&   R ? !!#&--b1>>&))%%b)004 ""--0u p  s%!%M+;AM>+ M;:M;> N  N c[U5(ag[5nUbU[RLaUR 5$[ XR 55$)a Return the rank of the current process in the provided ``group``, default otherwise. 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 r)rr|r0rgrr_rs rmrErEsK"%  #%J }!2!22  %!2 33roc:[U5(ag[U5$)a Return 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)rrWrs rmrFrFs%   5 !!rordst group_dstc[U5n[X!U5n[US5 [U5(a [ S5 gUR 5(a[ R"U5nURU/XC5$)a Send a tensor asynchronously. .. warning:: Modifying ``tensor`` before the request completes causes undefined behavior. .. warning:: ``tag`` is not supported with the NCCL backend. Unlike send, which is blocking, isend allows src == dst rank, i.e. send to self. Args: tensor (Tensor): Tensor to send. dst (int): Destination rank on global process group (regardless of ``group`` argument) 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 group_dst (int, optional): Destination rank on ``group``. Invalid to specify both ``dst`` and ``group_dst`` Returns: A distributed request object. None, if not part of the group rrSN) rrr rrrr view_as_realr])rrrHrrs rmrSrS sm@ $E *E(Y?I*%  7# ##F+ ::vh //rosrc group_srcc.[US5 [U5(a [S5 gUR5(a[R "U5n[ U5nUcUcURU/U5$[X!U5nURU/XC5$)a Receives a tensor asynchronously. .. warning:: ``tag`` is not supported with the NCCL backend. Unlike recv, which is blocking, irecv allows src == dst rank, i.e. recv from self. Args: tensor (Tensor): Tensor to fill with received data. src (int, optional): Source rank on global process group (regardless of ``group`` argument). 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 group_src (int, optional): Destination rank on ``group``. Invalid to specify both ``src`` and ``group_src``. Returns: A distributed request object. None, if not part of the group rrJN) r rrrrrrrecv_anysourcerrX)rrrHrrs rmrJrJ: s:*%  7# ##F+ #E *E {y(##VHc22,UC zz6(I33roc[U5n[X!U5n[X$S5 [XX4S9nUbUR 5 gg)af Send a tensor synchronously. .. warning:: ``tag`` is not supported with the NCCL backend. Args: tensor (Tensor): Tensor to send. dst (int): Destination rank on global process group (regardless of ``group`` argument). 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 group_dst (int, optional): Destination rank on ``group``. Invalid to specify both ``dst`` and ``group_dst``. destination)rHrrN)rrrrSr)rrrHrrworks rmr]r]g sD0 $E *E(Y?I=9 # CD  roc[XX#US9nUcgUR5 Uc5UcUR5n[U5n[ X$S5 [ X$5nU$)a Receives a tensor synchronously. .. warning:: ``tag`` is not supported with the NCCL backend. Args: tensor (Tensor): Tensor to fill with received data. src (int, optional): Source rank on global process group (regardless of ``group`` argument). 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 group_src (int, optional): Destination rank on ``group``. Invalid to specify both ``src`` and ``group_src``. Returns: Sender rank -1, if not part of the group )rrHrrrsource)rJr _source_rankrrr`)rrrHrrrs rmrXrX s_6 ) LD |IIK {  ))+I'.Ux8e/ Jroc\rSrSrSrSrg) _IllegalWorki c.US;a[SUS35eg)N) is_success exceptionr source_rankrresult synchronizezIllegal to call z on IllegalWork objectr)rrs rmr_IllegalWork.__getattribute__ s,   /v5KLM M rorN)rrjrrrrrrormrr s Nrorc2\rSrSrSSjrS\4SjrSrSrg) _CoalescingManageri Nc/Ulgrworksrs rmr_CoalescingManager.__init__ s !# rorcJU(aURRU5 ggr)rrrrs rmr_CoalescingManager.append s  JJ  d # rocJURHnUR5 M gr)rrrs rmr_CoalescingManager.wait sJJD IIKrorr) rrjrrrr!rrrrrormrr s$$4$ror async_opsc## U=(d [5n[RRU/5nU(a [ S5eU(aUR U5 [ 5nUv [RRU5nU(GaxUSRnU[:XaUUVs/sHofRPM nn[5n[USR5UlURXx5n GO U[ :Xa^/n /n UHBnU R#UR5 U R#[UR$55 MD UR'X5n OU[(:Xa/n /n UHBnU R#UR5 U R#[UR$55 MD [+5n [USR5U lUR-XU 5n O[/SUSUS35eU(aUR1U5n U(aUR#W 5 gW R35 gs snf7f)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, dtype=torch.float32) + 2 * rank >>> recv_tensor = torch.randn(2, dtype=torch.float32) >>> 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. rNrrgcLUR[:XaSOSnXR0$)Nrr)rrSr)rrs rm peer_kwarg%batch_isend_irecv..peer_kwargS s UUe^k]]##roT)r)rHr)rrHr|rrr1rrrrlrrsupports_coalescingrrrrr)rrHrrrrreqsrs rmr:r:# sMT{# N E }"$ ^ " " ) )F$u$c3h$ E{l"u'9'9&'A'U'U $ ?2% MM ,, !( &@xx!F99 llJJV$ D t D!" -@ ?xxs AE E.async_opc[U5n[X!USS9n[US5 [U5(a [ S5 g[ 5nXElSUlX5lURU/U5nU(aU$UR5 g)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 on global process group (regardless of ``group`` argument). 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 group_src (int): Source rank on ``group``. Must specify one of ``group_src`` and ``src`` but not both. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group Frrr;Nr) rrr rrrrootRank rootTensorasyncOpr;r)rrrHrroptsrs rmr;r;r sx: $E *E(YeTI*%  ;'  DMDOL ??F8T *D  roc U4n[U5(a[[UUUUUS9$[US5 [ U5(a [ S5 gUR 5(a5[U5(d[SUS35e[R"U5n[5nXl Uc [5nU[RR!5;aG[#[USUS5n[RUR%U5 U(a ['5$gUR)U/U5nU(aU$UR+5 g)a Reduces the tensor data across all machines in 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. >>> device = torch.device(f"cuda:{rank}") >>> tensor = torch.arange(2, dtype=torch.int64, device=device) + 1 + 2 * rank >>> tensor tensor([1, 2], device='cuda:0') # Rank 0 tensor([3, 4], device='cuda:1') # Rank 1 >>> dist.all_reduce(tensor, op=ReduceOp.SUM) >>> tensor tensor([4, 6], device='cuda:0') # Rank 0 tensor([4, 6], device='cuda:1') # 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, device=device ... ) + 2 * rank * (1 + 1j) >>> tensor tensor([1.+1.j, 2.+2.j], device='cuda:0') # Rank 0 tensor([3.+3.j, 4.+4.j], device='cuda:1') # Rank 1 >>> dist.all_reduce(tensor, op=ReduceOp.SUM) >>> tensor tensor([4.+4.j, 6.+6.j], device='cuda:0') # Rank 0 tensor([4.+4.j, 6.+6.j], device='cuda:1') # Rank 1 rrHrrr5Nall_reduce does not support  on complex tensors)r%r$r5r rrrr^rrrrrwr|rfrOrXrrr allreducer)rrrHr relevant_argsrcollrs rmr5r5 s%lIM-(($      *%  <( ##;B4?RST T##F+  DM }"$ ((--//z64T:  '..t4 > ! ??F8T *D  roz`torch.distributed.all_reduce_coalesced` will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/main/distributed.html#collective-functionscR[U[R5(aU/n[US5 [ U5 [ U5(a [ S5 g[SU55(a[U5(d[SUS35eUVs/sH/oDR5(dUO[R"U5PM1 nn[5nXl U=(d [5nURX5nU(aUR!5$UR#5 gs snf)aN 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 (Union[List[Tensor], 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. rr6Nc3@# UHoR5v M g7fr)r)rts rmr'all_reduce_coalesced..3 s +7a<<>>7srr)rrrrrrranyr^rrrrrwr|r get_futurer)rrrHrrrrs rmr6r6 sR'5<<(()w)"7+%  12 +7 +++4DR4H4H7t;NOPPKRS7a qE,>,>q,AA7GS $ &DM  )')E  $ $W 3D   Ts6D$c[U5n[X1USS9n[US5 [U5(a [ S5 g[ 5nX&lXVlURU/U5nU(aU$UR5 g)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 on global process group (regardless of ``group`` argument) 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 group_dst (int): Destination rank on ``group``. Must specify one of ``group_dst`` and ``dst`` but not both. Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group FrrrYN) rrr rrrrwrrYr)rrrrHrrrrs rmrYrYC sq@ $E *E(YeTI*%  8$ ?DMM <<$ 'D  roc [S5R5 [R"5n[ U5R U5 [ RRUR55n[ R"U5RU5n[5[R:Xa}[5(an[!U5nU["R$:XaO[ R&R(R+U/5n[,R/SUR15U5 [ R2"UR15/5RU5nXX4sSSS5 $!,(df  g=f)Nz+pytorch.wait_counter.c10d._object_to_tensorz)_object_to_tensor size: %s hash value: %s)r#guardr4BytesIO_picklerdumpr ByteStorage _from_bufferr6 ByteTensortorrrgrOrCr.rrr _hash_tensorsrwarningnumel LongTensor) rrrHf byte_storage byte_tensorrhash local_sizes rm_object_to_tensorrt s C D J J L JJL ((55ajjlC &&|477?   1 1 16G6I6I!%(G',,&xx11?? N?%%' %%{'8'8':&;<??G &% M L Ls EE55 FcX[S5R5 [5[R:Xa}[ 5(an[ U5nU[R:XaO[RRRU/5n[RSUR5U5 UR!5nUR#5R%5SUn['[(R*"U55R-5sSSS5 $!,(df  g=f)Nz+pytorch.wait_counter.c10d._tensor_to_objectz)_tensor_to_object size: %s hash value: %s)r#rrrrgrOrCr.rrrrrrrrrnumpytobytes _unpicklerr4rload)r tensor_sizerHrrr;s rm_tensor_to_objectr s C D J J L   1 1 16G6I6I!%(G',,&xx11??I?QUlln$$&| 4"**S/*//1 M L Ls C7D D)c[U5(a [S5 g[U5n[XU5upE[ US9n[ R "U[ RUS9n[U5Vs/sHoURSS9PM n n[XUS9 [[U 5R55n URU 5 [ R"X-[ R US9n [U5Vs/sHnXU-XS--PM n n[XUS9 [#U 5H6upU R%[ R 5n Xn['XU5X'M8 gs snfs snf)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}] r4Nrrrrdimr')rrr~rrFrzeroslongrI unsqueezer2rritemresize_emptyuint8 enumeraterlr) object_listrrHcurrent_device input_tensorrrVobject_sizes_tensorrLobject_size_listmax_object_sizecoalesced_output_tensoroutput_tensorsrrs rmr4r4 shl%  ./,U3N0eLL e,J++%**^:?z9J9JAA((Q(/9J59#./4467O)#kk$EKK z""A ! 3oQ6OP"~59~. U[[)&) *6F /%s 0E%=E*robject_gather_listc[U5nUcUcSn[X2USS9n[U5(a [S5 g[ 5n[ XeU5 [ U5n[XU5up[US9n [R"U [RUS9n [U 5V s/sHoU RSS9PM n n [XUS9 [[!U 5R#55nUR%U5 Xe:XaK[R&"X-[R(US9n[U 5V s/sHn XU -XS --PM nn [+UXe:XaWOSUUS 9 Xe:wagUcS 5e[-W5H8un nUR/[R(5nXn[1UUU5X'M: gs sn fs sn f) aB 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 on global process group (regardless of ``group`` argument). (If both ``dst`` and ``group_dst`` are None, default is global rank 0) group: (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. group_dst (int, optional): Destination rank on ``group``. Invalid to specify both ``dst`` and ``group_dst`` 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}] NrTrrArrrr') gather_listrrHz+Must provide object_gather_list on dst rank)rrrrrE_validate_output_list_for_rankr~rrFrrrrIrr2rrrrrrr@r rlr)rrrrHr global_dstmy_global_rankr r rrVr rLrrrrrrs rmrArA sH $E *E {y()%itTJ%  ?+ZN">?QR,U3N0eLL e,J++%**^:?z9J9JAA((Q(/9J 59#./4467O)#"'++  ( N#  :& & $a$7/QRU:S T&   &4&BN   #  )X+XX )~. 6U[[)&) 1&+u M/?  s $F96F>r c [U5n[X!U5n[X$S5 [U5(a [ S5 gU=(d [ U5n[ UVs/sHn[XeU5PM sn6upx[R"U5n [XUS9 [U5S:XaUSn O[R"U5n [XUS9 gs snf)a Sends picklable objects in ``object_list`` synchronously. Similar to :func:`send`, but Python objects can be passed in. Note that all objects in ``object_list`` must be picklable in order to be sent. Args: object_list (List[Any]): List of input objects to sent. Each object must be picklable. Receiver must provide lists of equal sizes. dst (int): Destination rank to send ``object_list`` to. Destination rank is based on global process group (regardless of ``group`` argument) 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 sending. Default is ``None``. group_dst (int, optional): Destination rank on ``group``. Must specify one of ``dst`` and ``group_dst`` but not both Returns: ``None``. .. 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()``. .. warning:: :func:`send_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:`send_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:`send` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> # Assumes backend is not NCCL >>> device = torch.device("cpu") >>> if dist.get_rank() == 0: >>> # Assumes world_size of 2. >>> objects = ["foo", 12, {1: 2}] # any picklable object >>> dist.send_object_list(objects, dst=1, device=device) >>> else: >>> objects = [None, None, None] >>> dist.recv_object_list(objects, src=0, device=device) >>> objects ['foo', 12, {1: 2}] rr<N)rrHr'r) rrrrrr~ziprrcatr]r) r rrHrrr r tensor_list size_listr  object_tensors rmr<r<p s@ $E *E(Y?I=9%  -.=6u=N CN O;C C 7; OK ))I. ?  ;1#A  +. 59 PsCc&[U5(a [S5 gU=(d [U5n[R"[ U5[R US9n[XaX$S9n[R"[R"U5R5[RUS9n[XX$S9n Xy:XdS5eSn [U5H<upXX-n U R[R5n X- n [XU5X 'M> U $)a Receives picklable objects in ``object_list`` synchronously. Similar to :func:`recv`, but can receive Python objects. Args: object_list (List[Any]): List of objects to receive into. Must provide a list of sizes equal to the size of the list being sent. src (int, optional): Source rank from which to recv ``object_list``. Source rank is based on global process group (regardless of ``group`` argument) Will receive from any rank if set to None. Default is ``None``. 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, receives on this device. Default is ``None``. group_src (int, optional): Destination rank on ``group``. Invalid to specify both ``src`` and ``group_src``. Returns: Sender rank. -1 if rank is not part of the group. If rank is part of the group, ``object_list`` will contain the sent 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()``. .. warning:: :func:`recv_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:`recv_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:`recv` instead. Example:: >>> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> # Assumes backend is not NCCL >>> device = torch.device("cpu") >>> if dist.get_rank() == 0: >>> # Assumes world_size of 2. >>> objects = ["foo", 12, {1: 2}] # any picklable object >>> dist.send_object_list(objects, dst=1, device=device) >>> else: >>> objects = [None, None, None] >>> dist.recv_object_list(objects, src=0, device=device) >>> objects ['foo', 12, {1: 2}] r=rr)rrHrz6Mismatch in return ranks for object sizes and objects.r)rrr~rrrrrXsumrrr rlr)r rrHrrr r  rank_sizesr rank_objectsoffsetrLobj_sizeobj_views rmr=r= s~%  -.=6u=N++ K > )%UJKK %&++-kkM  eQL  %@ %F !45  &*;<==-*8uE  6 roc V[U5nUcUcSn[X!USS9n[U5(a [S5 gU=(d [ U5n[ 5nXu:Xa<[ UVs/sHn[XU5PM sn6up[R"U 5n O-[R"[U5[RUS9n [XUS9 Xu:Xa,[W 5S:XaU Sn O][R"U 5n OF[R"[R"U 5R5[R US9n [XUS9 Sn Xu:waL[#U 5H<upXX-nUR%[R 5nX- n ['UX5X'M> ggs snf) 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``. Source rank is based on global process group (regardless of ``group`` argument) 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``. group_src (int): Source rank on ``group``. Must not specify one of ``group_src`` and ``src`` but not both. 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:`broadcast` 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}] NrTrr>rrrHr')rrrrr~rErrrrrrrr;rrrr rlr)r rrHrr global_srcr rrrrr rr"rLr#r$s rmr>r>9 sL $E *E {y()%itTJ%  23=6u=NZN#!$GR S{U;{ S"  $ii 2#kk  EJJ~  !? # { q 'NM!IIk2M II) * / / 1++! m59 F#$%89KA$f.?@H}}U[[1H  F.xIKN :$;Ts'F&scatter_object_output_listscatter_object_input_listc f[U5nUcUcSn[X2USS9n[U5(a [S5 g[ U[ 5(a[ U5S:a [S5e[5n[U5nXe:XanUc [S5e[UVs/sHn[XU5PM sn6up[ U 5[ U 5p[U 5n U Hn U RU 5 M O%[R"S/[R US 9n [#XUS 9 [R$"U R'5[R(US 9n [+U Xe:waSOW UUS 9 [R"S/[R US 9n[+UXe:waSOW UUS 9 [-XU5US'gs snf) as 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], optional): 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``. Source rank is based on global process group (regardless of ``group`` argument). (If both ``src`` and ``group_src`` are None, default is global rank 0) group: (ProcessGroup, optional): The process group to work on. If None, the default process group will be used. Default is ``None``. group_src (int, optional): Source rank on ``group``. Invalid to specify both ``src`` and ``group_src`` 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}] NrTrr\r'zMExpected argument scatter_object_output_list to be a list of size at least 1.z;source rank must provide non-None scatter_object_input_listrr&) scatter_listrrH)rrrrrrrrrEr~rrrrrrrr;rrrr[r)r(r)rrHrr'r pg_devicerr tensor_sizesmax_tensor_sizer output_tensorobj_tensor_sizes rmr\r\ s@ $E *E {y()%itTJ%  01 14 8 8 ) *Q . [  ZN'.I# $ ,M %(54C"#%84% ! %)$5tL7I\l+!F NN? +" ,,s%**YO oU;KKekk)M +9T{  llA3ejjKO +9T|  %6%q!KsF.c (U4n[U5(a[[UUUUUS9$[US5 [ US5 [ X5 [ U5(a [S5 gUVs/sH/oUR5(dUO[R"U5PM1 nnUR5(dUO[R"U5nU=(d [5nURU/U/5nU(aU$UR5 gs snf)a Gathers tensors from the whole group in a list. Complex and uneven sized tensors are supported. Args: tensor_list (list[Tensor]): Output list. It should contain correctly-sized tensors to be used for output of the collective. Uneven sized tensors are supported. 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. >>> device = torch.device(f"cuda:{rank}") >>> tensor_list = [ ... torch.zeros(2, dtype=torch.int64, device=device) for _ in range(2) ... ] >>> tensor_list [tensor([0, 0], device='cuda:0'), tensor([0, 0], device='cuda:0')] # Rank 0 [tensor([0, 0], device='cuda:1'), tensor([0, 0], device='cuda:1')] # Rank 1 >>> tensor = torch.arange(2, dtype=torch.int64, device=device) + 1 + 2 * rank >>> tensor tensor([1, 2], device='cuda:0') # Rank 0 tensor([3, 4], device='cuda:1') # Rank 1 >>> dist.all_gather(tensor_list, tensor) >>> tensor_list [tensor([1, 2], device='cuda:0'), tensor([3, 4], device='cuda:0')] # Rank 0 [tensor([1, 2], device='cuda:1'), tensor([3, 4], device='cuda:1')] # 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, device=device) for _ in range(2) ... ] >>> tensor_list [tensor([0.+0.j, 0.+0.j], device='cuda:0'), tensor([0.+0.j, 0.+0.j], device='cuda:0')] # Rank 0 [tensor([0.+0.j, 0.+0.j], device='cuda:1'), tensor([0.+0.j, 0.+0.j], device='cuda:1')] # Rank 1 >>> tensor = torch.tensor( ... [1 + 1j, 2 + 2j], dtype=torch.cfloat, device=device ... ) + 2 * rank * (1 + 1j) >>> tensor tensor([1.+1.j, 2.+2.j], device='cuda:0') # Rank 0 tensor([3.+3.j, 4.+4.j], device='cuda:1') # Rank 1 >>> dist.all_gather(tensor_list, tensor) >>> tensor_list [tensor([1.+1.j, 2.+2.j], device='cuda:0'), tensor([3.+3.j, 4.+4.j], device='cuda:0')] # Rank 0 [tensor([1.+1.j, 2.+2.j], device='cuda:1'), tensor([3.+3.j, 4.+4.j], device='cuda:1')] # Rank 1 rHrrrr2N)r%r$r2rr rrrrrrr| allgatherr)rrrHrrrrs rmr2r29s~IM-(($       {M2*";7%  <(EPDOqU%7%7%::K",,..VE4F4Fv4NF  )')E ??K=6( 3D  s)6Dc U4n[U5(a[[UUUUUS9$[US5 [US5 [ U5(a [ S5 gUR 5(dUO[R"U5nUR 5(dUO[R"U5n[5nX5l U=(d [5nU[RR5;aD[[X5n[RUR!U5 U(a [#5$gUR%XU5nU(aU$UR'5 g)a Gather tensors from all ranks and put them in a single output tensor. This function requires all tensors to be the same size on each process. 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. r2r r/rcN)r%r$rcr rrrrrrrr|rfrOrXrrr_allgather_baser)r/r rHrrrrrs rmrcrcs@t"OM-(($ "      ~68%  34''))     .&&((     -  DL  )')E ((--//-|K  '..t4 > !  d CD  roz`torch.distributed._all_gather_base` is a private function and will be deprecated. Please use `torch.distributed.all_gather_into_tensor` instead.c[XX#5$)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. )rc)r/r rHrs rm_all_gather_baser7s6 "-u OOroz`torch.distributed.all_gather_coalesced` will be deprecated. If you must use it, please revisit our documentation later at https://pytorch.org/docs/main/distributed.html#collective-functionsc [U5(a [S5 g[US5 [U5 [ U[ 5(d [ S5eUHn[US5 [U5 M UVVs/sH@nUVs/sH/ofR5(dUO[R"U5PM1 snPMB nnnUVs/sH/ofR5(dUO[R"U5PM1 nnU=(d [5nURX5nU(aUR5$UR5 gs snfs snnfs snf)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. r3Ninput_tensor_listz?Invalid function argument: output_tensor_lists should be a listoutput_tensor_lists)rrrrrrrsrrrr|allgather_coalescedrr)r:r9rHroutput_tensor_listlrrs rmr3r3"s?n%  12(*=>"#45 )4 0 0 M  2-/DE&'9:2 %$AFGGQ,,..e&8&8&; ;QG$ EVDUqU%7%7%::DU  )')E  $ $%8 LD    Hs9 E6E 9E6E EcXX:XaU(d [S5egU(a [S5eg)Nz?Argument ``gather_list`` must be specified on destination rank.zHArgument ``gather_list`` must NOT be specified on non-destination ranks.r)my_rankrrs rmrrws9 ~Q   V   rorc[US5 U(a [US5 O/n[X5 [U5n[ U5(a [ S5 gUcUcSn[ X2USS9n[ X2USS9n[5n[XvU5 Xg:XaU/O/nU/n [5n XZl URXU 5n U(aU $U R5 g) a Gathers a list of tensors in a single process. This function requires all tensors to be the same size on each process. Args: tensor (Tensor): Input tensor. gather_list (list[Tensor], optional): List of appropriately, same-sized tensors to use for gathered data (default is None, must be specified on the destination rank) dst (int, optional): Destination rank on global process group (regardless of ``group`` argument). (If both ``dst`` and ``group_dst`` are None, default is global rank 0) 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 group_dst (int, optional): Destination rank on ``group``. Invalid to specify both ``dst`` and ``group_dst`` Returns: Async work handle, if async_op is set to True. None, if not async_op or if not part of the group .. note:: Note that all Tensors in gather_list must have the same size. Example:: >>> # xdoctest: +SKIP("no rank") >>> # We have 2 process groups, 2 ranks. >>> tensor_size = 2 >>> device = torch.device(f'cuda:{rank}') >>> tensor = torch.ones(tensor_size, device=device) + rank >>> if dist.get_rank() == 0: >>> gather_list = [torch.zeros_like(tensor, device=device) for i in range(2)] >>> else: >>> gather_list = None >>> dist.gather(tensor, gather_list, dst=0) >>> # Rank 0 gets gathered data. >>> gather_list [tensor([1., 1.], device='cuda:0'), tensor([2., 2.], device='cuda:0')] # Rank 0 None # Rank 1 rrr@NrTrF) r rrrrrrrErrrr@r) rrrrHrrrrr input_tensorsrrs rmr@r@sb*; 6 "67 #E *E%  8$ {y()%itTJ(YeTIZN">{K&0&Bk]NHM ?DM <<t >> # xdoctest: +SKIP("need process group init") >>> # Note: Process group initialization omitted on each rank. >>> import torch.distributed as dist >>> tensor_size = 2 >>> device = torch.device(f'cuda:{rank}') >>> output_tensor = torch.zeros(tensor_size, device=device) >>> if dist.get_rank() == 0: >>> # Assumes world_size of 2. >>> # Only tensors, all of which must be the same size. >>> t_ones = torch.ones(tensor_size, device=device) >>> t_fives = torch.ones(tensor_size, device=device) * 5 >>> scatter_list = [t_ones, t_fives] >>> else: >>> scatter_list = None >>> dist.scatter(output_tensor, scatter_list, src=0) >>> # Rank i gets scatter_list[i]. >>> output_tensor tensor([1., 1.], device='cuda:0') # Rank 0 tensor([5., 5.], device='cuda:1') # Rank 1 rr+NrTrFr[z;Argument ``scatter_list`` must be specified on source rank.zDArgument ``scatter_list`` must NOT be specified on non-source ranks.)r rrrrrrrrrrErrrrr[r) rr+rrHrrr'rrrArrrs rmr[r[sSp*<8 "68 #E *E {y()%itTJ(YeTI%  9%DPDPqU%7%7%::L",,..VE4F4Fv4NFZN#M &   V     DML == =D  ;s76Ec$[US5 [US5 [X5 [U5(a [ S5 g[ 5nX%lU=(d [5nURU/U/U5nU(aU$UR5 g)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_listrZN) r rrrrrrwr|rZr)rDrErrHrrrs rmrZrZ:s{(*z<0"66%  +,  !DM  )')E   :, =D  roc 0U4n[U5(a[[UUUUUUS9$[US5 [US5 [ U5(a [ S5 g[ 5nX&lXFlU=(d [5nU[RR5;aF[[XUS5n[RURU5 U(a [5$gUR!XU5nU(aU$UR#5 g)a; Reduces, then scatters a tensor to all ranks in a group. Args: output (Tensor): Output tensor. It should have the same size across all ranks. input (Tensor): Input tensor to be reduced and scattered. Its size should be output tensor size times the world size. The input tensor can have one of the following shapes: (i) a concatenation of the output tensors along the primary dimension, or (ii) a stack of the output tensors along the primary dimension. For definition of "concatenation", see ``torch.cat()``. For definition of "stack", see ``torch.stack()``. 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_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. rrDinputrdN)r%r$rdr rrrrwrr|rfrOrXrrr_reduce_scatter_baser) rDrGrrHrrrrrs rmrdrdastHM-(($ !     *(%  23  !DML  )')E ((--//,eRF  '..t4 > !  % %fT :D  roz`torch.distributed._reduce_scatter_base` is a private function and will be deprecated. Please use `torch.distributed.reduce_scatter_tensor` instead.c[XX#U5$)at 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. )rd)rDrGrrHrs rmrHrHs2 !8 DDroc *U4n[U5(a[[UUUUUUUS9$[U5(a [ S5 g[ 5n[ US5 [ US5 [X5 UR5(a[R"U5nUR5(a[R"U5nUc/OUnUc/OUnU=(d [5nURXX#U5nU(aU$UR5 g)a Split input tensor and then scatter the split list to all processes in a group. Later the received tensors are concatenated from all the processes in the group and returned as a 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 )output_split_sizesinput_split_sizesrHrr8NrDrG)r%r$r8rrrr rrrrr| alltoall_baser) rDrGrKrLrHrrrrs rmr8r8s PHM-(($    1/  %  ./  D*("61 ""5) ##F+19?Q/7=N  )')E   )d D  roc[U5(a [S5 g[5n[US5 [US5 [ X5 UVs/sH/oUR 5(dUO[ R"U5PM1 nnUVs/sH/oUR 5(dUO[ R"U5PM1 nnU=(d [5nURXU5nU(aU$UR5 gs snfs snf)aY 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 r7Nr<r9) rrrrrrrrr|alltoallr)r<r9rHrrrrs rmr7r7ssz%  <(  D)+?@(*=>"#5IEVDUqU%7%7%::DUEWDVqU%7%7%::DV  )')E >>, FD  s 6D 6Dcb[U5(a [S5 g[5n[R"[ U55UlUb'[ U[5(aX#lO [S5eU=(d [5nURUS9nU(aU$UR5 g)a Synchronize 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 .. note:: `ProcessGroupNCCL` now blocks the cpu thread till the completion of the barrier collective. r9Nz>Invalid function argument: device_ids type should be List[int])r) rrrrrr~rr device_idsrsr|r9r)rHrrQrrs rmr9r9s,%  9%  D,,6u=>DK j$ ' '(OP   )')E ==d= #D  roc|[U5(a [S5 g[U5[R:wa [ S5eUc[ [U55nO8[U[5(a#[R"SUS35 [US9n[U5 Uc [5OUnURXS9$)aU Synchronize processes similar to ``torch.distributed.barrier``, but consider a configurable timeout. It is able to report ranks that did not pass this barrier within the provided 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. rTNz7monitored_barrier is only implemented for GLOO backend.zGPlease specify timeout arg as a timedelta. Converting current value of z assuming it represents secondsr)wait_all_ranks)rrrCr.rrrprfloatrrrrur|rT)rHrqrS group_to_uses rmrTrTsl%  ./5W\\)RSS&{5'9: GU # #  ++2)3R T G,!+0=%'eL  ) ) * rorPrUc[(dS5e[SU3n[Xb5n[X#XES9n[ X5nU$)Nz5ProcessGroupWrapper unsupported without GLOO backend.rrt)rPG_WRAPPER_STORE_PREFIXrrsrr)rPrUrrrrqprefix helper_pgs rmrhrhesM ?SSS? ((, 8F  &E jJI%j&?@AJ <<j'2E J T T VVroc[U5n[U5nS[R"[R5S-S- -n[ U5U-nU$)Nrr')rarctypessizeofc_intabs)rU hash_value max_c_intcolors rmrarasJ %LEeJ fmmFLL1A59:I  Oi 'E LrocU(a [U5nU$[[R5n[=RS- slU$Nr')rbrrfrE)rUr*rRs rmrErEs@$U+ Nf(()a NrocLU(d[[55n[U5$r)rCr|r.ros rm_get_backend_from_strros  023 7 roc4[5RcS$S$)z Checks if it is safe to split the any process group in the world. This is only safe if the default pg has a bound device id, otherwise users must be aware that a pg is only splittable after the first collective is issued. FT)r|rNrrorm_is_safe_to_splitrqs'(88@5JdJro parent_pg split_ranksrYcV Uc [S5e[5nURnU(d [S5e[R UupxUR 5n UR5n U(dUnU[R;a[SUS35e[RUn U R5V V s0sHupX_M n n n W U ;a[SU SU35eXnUR[R"S55nU(a&UR(a[U[5(d [S 5eUcUR S UR#53OUn[R Uunn[%U5n['U5nUb'[U[R(5(dS 5eO UR*nUc [-U5n[/U5 SnS n UHn[1U5S :Xa [S5e[1U5U :a [S5e[1U5[1[3U55:wa [S5e[5U5nUU;dMvUnUR7U5n O UbU S :XaUR9U5 g[;USS9nUVs/sHnU UPM nn[=US3U5n[?UU [1U55n[>R@RBnUUlUREU5 X#l#Xl$[KU5Ul&UUl'UUl([UU [1U5U5nURS5 URU[R"S5UU5 UceUceURWU5 URYU5 URU5nUR[U5 UU4[R U'U[R\U'[_UU5 [aU5[RbU'SU3n[RdRgU/5RiU5 U[RjU'[mU5V V s0sHupX_M sn n [RU'U$s sn n fs snfs sn n f)a Create a new process group splitted from the given parent process group. warning:: This is an experimental API and only the ``NCCL`` backend supports this API. Other backends will raise an error. Users of this API must gurantee that all ranks in the parent group enter this API call, and the split of the sub groups is the same across all ranks in the parent group. Args: parent_pg (ProcessGroup, optional): The parent process group. If None, the default process group will be used. Users need to gurantee that the parent group is fully initialized (e.g, communicators are initialized) split_ranks (list[list[int]]): the split ranks, which is a list of list of ranks. Users need to make sure the validity of the split ranks such that one split (represented by one inner list of ints) does not overlap with any other split. Note that the ranks in each split is the group rank (instead of global rank) in the parent pg. For example, if the parent group has 4 ranks, and split_ranks can be [[0, 1], [2, 3]]. Note [[0,1]] is also a valid split, in which case ranks 2, 3 would return a non-group member. timeout (timedelta, optional): see `init_process_group` for details and default value. pg_options (ProcessGroupOptions, optional): only ProcessGroupNCCLOptions is supported now. specifying what additional options need to be passed in during the construction of specific process groups. i.e.``is_high_priority_stream`` can be specified so that process group can pick up high priority cuda streams. For other availble options to config nccl, See https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/api/types.html#ncclconfig-t group_desc (str, optional): a string to describe the process group. Returns: ProcessGroup if the current rank is within one split/subgroup given by split_ranks, or None if the current rank is not part of any split_ranks`. Nzsplit_ranks cannot be NonezNNo device associated with the default pg, not safe to split any process groupsrz is not registeredrz! is not part of the parent group rzQNo backend for the parent process group or its backend does not support splittingz:split:zCExpected pg_options argument to be of type ProcessGroupNCCL.Optionsrrzthe split group cannot be emptyzZthe split group's size should be less or equal to the world_size set by init_process_groupz+the split group cannot have duplicate ranksFr)rTrV)7rr|rNrrfr7rrr=rrrrrOrrqrYcomm_split_countr.r/r^optionsrprurrrrYrZrErrrrr[r_rQrarbrcrrerirjrkrlr:r rr@rIrmrrLr )rrrsrqr&rYr r'_default_backendrrglobal_world_sizeparent_global_to_group_ranksrparent_group_to_global_ranksparent_group_rankparent_backendparent_backend_strrrrTmy_grouprfrrglobal_ranks_in_my_grouprpr\rurtrxrns rmrfrfsT566$%J**I  \  '-mmJ&?#//#K")  ---6),>?@@#)#8#8#C (D'I'I'K$'K #K 'K!$ 66;-'H T  5A++ELL,@AN 00.*:;; _        (G(G(I'JK  #MM)4()G"7+N*&6&>&>?? Q ? $++ &w/!HJ" { q >? ? { / /l  { s3{#34 4JK K[)  +"H$**+<=J # :+,,Y7$XuEJOWXxt R"R 5R%c "[UUUUSUUUS9$)aY Create 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:: Safe concurrent usage: When using multiple process groups with the ``NCCL`` backend, the user must ensure a globally consistent execution order of collectives across ranks. If multiple threads within a process issue collectives, explicit synchronization is necessary to ensure consistent ordering. When using async variants of torch.distributed communication APIs, a work object is returned and the communication kernel is enqueued on a separate CUDA stream, allowing overlap of communication and computation. Once one or more async ops have been issued on one process group, they must be synchronized with other cuda streams by calling `work.wait()` before using another process group. 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): see `init_process_group` for details and default value. 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. For other availble options to config nccl, See https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/api/types.html#ncclconfig-t 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. group_desc (str, optional): a string to describe the process group. device_id (torch.device, optional): a single, specific device to "bind" this process to, The `new_group` call will try to initialize a communication backend immediately for the device if this field is given. Returns: A handle of distributed group that can be given to collective calls or GroupMember.NON_GROUP_MEMBER 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_synchronizationrYr')_new_group_with_tag)rUrqrr&rrYr's rmrUrUms*^   ";  rocF[5nUc URnO#URbXxR:XdS5e[RUupUR 5n UR 5n U(dU n[ U5nUc [U5n[U5 U(a1U[ R:Xa [S5eUb[5U;agUb_[U5n[U5n X:a [S5eUHnUS:dX:dM[S5e X;aURU 5nOSnO[[!U 55nU n U n[#XS9n[%U UUUU UUUUUUS9 unn['U5VV s0sHupX_M sn n[R(U'[+5S :Xak[,R/S 5 U[ R:Xa [15 U$U(aUOU nU(a [U5O [35n[5W UUUU5 U$s sn nf) z 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. Nz:Mismatched bound device between new pg and the default pg.z:MPI backend doesn't support use_local_synchronization=Truez^the new group's world size should be less or equal to the world size set by init_process_grouprzNThe new group's rank should be within the world_size set by init_process_groupr))r+rqrnr'rYr'r@)r|rNrfr7rrr.rprurrrErrrYrrIrErFr r=rrrr9rFr)rUrqrr+rnrrYr'r default_backendrrrxgroup_world_sizerrrr\r  barrier_storers rmrrsH$$%J..  # # /666 H 6&,]]:%>"O//#K") !gG&w/! gkk !L   5!8 u u:  /%  Dax44 ?  [1JJU,-., $UVJ, ' LB @I?O!?O$;J ?O!F"1$   *  gkk ! I I)BH}M'@UnFVJ !]J G  I;!s?Hc .UcL[RR5(d [S5e[RR 5nUS::a[SUS35e[ 5nX`:a[SUSUS35eX`-S:wa [S5e/nSn[ X`-5Hfn X-n X-n [[ X55n [U UUUUS 9n URU 5 [5nX;dMNU n[RS X5 Mh X4$) as Create subgroups of equal size. By default, it creates intra-machine subgroups, where each of which contains all the ranks of a machine, based on the assumption that each machine has the same number of devices. 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:: If ``group_size`` is passed in, the world size must be divisible by ``group_size``. If no ``group_size`` is passed in, it believe that you are creating a group based on CUDA and determining the group size by number of CUDA devices, and if not all the machines have the same number of devices, the subgroup division will be different across nodes and can cause unexpected behaviors. Therefore, if you are creating a subgroup that does not depend on CUDA (such as Gloo on CPU), please pass in ``group_size`` correctly. .. warning:: See warning `Safe concurrent usage` for `new_group` API for important details about using multiple process groups concurrently in a safe manner. 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): see `init_process_group` for details and default value. 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. group_desc (str, optional): A string describing the group. Each subgroup will inherit its group_desc 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([28]) # Assume 8 CUDA devices per machine. 28 is sum(range(8)). >>> # 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 (r z0The world size must be divisible by 'group_size'rUrqrr&rY"Rank %s is assigned to subgroup %s) rr is_availabler device_countrFrIrrUrrErr)rVrHrqrr&rYr subgroups cur_subgroup subgroup_id start_rankend_rankranks_in_subgroupsubgrouprs rmrVrVEs<Pzz&&((9  ZZ,,. Q1*=OPQQ!J$ZL0RS]R^^_ `  !#KLLILZ56  - * z!<=#!!   "z  $#L KKUb[U5S:Xa [S5e/nSn0nUHrn[UUUUUS9n URU 5 [ 5n UHAn X;a[SU SX{SU35eXU 'X:XdM)U n[ R SX5 MC Mt Xe4$) a+ Create subgroups by dividing the global world. 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:: See warning `Safe concurrent usage` for `new_group` API for important details about using multiple process groups concurrently in a safe manner. Args: ranks_per_subgroup_list (list[list[int]]): A nested list of ranks of group members. timeout (timedelta, optional): see `init_process_group` for details and default value. 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. group_desc (str, optional): A string describing the group. Each subgroup will inherit its group_desc. 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)rrrUrrErr) ranks_per_subgroup_listrqrr&rYrrrank_to_ranks_dictrUrr?rs rmrWrWsp&#.E*F!*KLMMIL(!!   "*D) D6!@ASAY@ZZ_`e_fg(-t $'  @$N)(  ""roch^[U5S:a1URS5(dURS5(dSU3n[RR U/5HMnUR 5[U5:waM"[ U5m[U4SjU55nU(dMKUs $ g)NrrVrWc3,># UH oT;v M g7frr)rrrs rmr,_find_pg_by_ranks_and_tag..s3U #Us)rrrfrIr rrar)rrUrHgoodrs @rmrrs 3x!|CNN6223>>';R;RcUm""&&sB/ ::<3u: % -e4 3U33 4L0 rostridec[U5U-S:XdS[U5SUS35e[5nSnU[U5:XaUR5nX4;dS5eO6[S[U5U5HnXXR-nX6;dMUnM UcS5e[ U5n[ X5nUbU$US:Xa [ S5e[X@S9$) NrzRanks length (z) must be divisible by stride (r z(rankset doesn't include the current noderz-Cannot automatically create PG with empty tag)rn)rrEcopyrIrrrr)rrUrr?my_ranksrLrank_setr\s rm#_find_or_create_pg_by_ranks_and_tagrs u: ! # U $CF81M #jGH U::<"N$NN"q#e*f-A,H"#.#O%OO#hH "3 1B ~  byHII x 44rocN[RUnURS5nU$)z&Return the tag associated with ``pg``.rW)rfrL removeprefix)r\rs rm_get_group_tagr<s'   2 C  7 #C JrocB[RRUS5$)NNone)rfr:r r\s rmrrCs ??  r6 **roc.[RUS$rm)rfr7rs rm_get_process_group_storerGs == Q rorr)NNF) NNNrrNrNN)NNNNNr)NNFN)NNNN)NF)NNNFN)NNNF)NNNNFNN)NNNNNFNN)NNNNNN)rcollections.abc collections contextlibrer\r4rloggingrpickler2rrrdatetimertypingrrrrr typing_extensionsr rtorch._Cr rtorch._C._distributed_c10dr r rrrrrrrrrrrrrrrrrrr r!torch._utils_internalr" torch.monitorr#torch.overridesr$r%torch.utils._typing_utilsr& c10d_loggerr(r) constantsr*r+r-r,__all__rrrrrPicklerr Unpicklerrrnrprj ImportErrorrqrrrsrtru getLoggerrrrWboolr^rr.r/rrbr1rr#rrarr$r%rr&rDr'rr(r)r+rfrlrcrHr0rprurvrr~rrrrrrr_r`rrrarWrrr rrrrabcIterablerrrrrMrOrKrQrRrNrLrPrr|rrrBrCrDrrrrGrer r$rIrRrFr?rrErFrrSrJr]rXrrcontextmanagerrr:r;SUMr5r6rYrrr4rAr<r=r>r\r2rcr7r3rr@r[rZrdrHr8r7rgr9rTrrrhrbrarErorqrfrUrrVrWrrrrrrrormrs2   "@@( 60N&E.8B?K Z >>    ?.:!EO !""G;"F "##GQ"F "##G:!EO !""G;"F "##G   8 $& $x $D $~Tc~TBM'M'`220 L C|C|L:24lE#u*-- .3%' 4 c! "'68lDcN238.0Ds*+0 -/ T#tL)) */&( Ds" #((3-||~ i"$j$J "' "i " # $ *.#-6>8L#9>S>BK(<"8KELLK\ ;h|4 ;S ;r* A AAH1h|411$,$S$S$8N<NSNSN8 N  (S(  ( 5< 5DI 5c S    8L#9\"& $ 8 8#8 8 8  8.  C C 4114( @&$ 4 4 $ 4 3#3$3()) 8$ 8:: !L ! E 6 )h|4))(*x -**(5ell1B+C.| (<0 DcN T$sCx.1cx}48 8d86(.Y(.x /E(.QU(.V !!%#'! $(,tO c]tO#tOi tO tO  tO E? tOtO tO %tO tOtOn:  bJ T1,!7T1nW1 6W1t4H\*4c46"(<0"C"*$(# *0 LL*0 #*0 L !*0 *0 } *0 d^ *0^$(# *4 LL*4 #*4 L !*4 *4 } *4 d^ *4Z$(#  LL # L !  }   >$(# $ LL$ #$ L !$ $ } $  $$N N4 N   $(%) %U L !U U\\ "U~UUpL4;L4:L^$(# + LL+ #+ L !+ + } ++\",,dU]]@ J  &.\\7 7t||$(# - LL- #- L ! -  - } --`', 2WGWGt/3$(# yN yN c+yN #yN L ! yN } yNyNx$(%)# _:c_: #_: L !_: U\\ " _: } _:_:D$(%)# bcb #b L !b U\\ " b } bbJ$(%)# zJczJ #zJ L !zJ U\\ " zJ } zJzJz6:$(# ~ $S ~'S 2~ #~ L ! ~ } ~~B[[|hhV E  P  P0 J BGK K\  15$(# L LLL$u||,-L #L L ! L  L } LL^26$(# c LLc4 -.c #c L ! c  c } ccL*2,,dU##L,4LLuaaH D  ,4<|+ ++  % qdNOONOsZ3hh%h41iih"!h"%h10h14i?iiiii