sg >UddlZddlZddlmZmZmZddlZddlmZ ddlm Z ddl m Z m Z ddlmZddlmZgdZdaeded <d e d efd Zd ed e d dfdZGddZGddeZGddeZy)N)DictListOptional)Tensor)_get_device_handle DeviceMesh) DTensorSpec)Shard)is_rng_supported_mesh manual_seedOffsetBasedRNGTrackerTensorParallelRNGTracker_RNGStateTracker _rng_tracker device_meshreturnct|j}|r t|drytjd|jdy)aFChecks if the current device of ``device_mesh`` supports DTensor's random APIs. Currently DTensor Random APIs only supports cuda/cuda-like devices. We suggest users call this API to test the availability before using our random APIs. Args: device_mesh (:class:`DeviceMesh`): The device mesh on which we check if the random ops APIs are supported. Returns: A bool value. True if ``device_mesh`` supports DTensor Random APIs; False otherwise. .. warning:: Currently we only support correct RNG on cuda/cuda-like devices. set_rng_stateTz:DTensor random operators may not have complete support on z device meshF)r device_typehasattrwarningswarn)r device_handles S/var/www/html/venv/lib/python3.12/site-packages/torch/distributed/tensor/_random.pyr r sJ'{'>'>?M@  HI`I`Haam n seedc t|j}|std|j|gtjz}tj ||t |D]B\}}|t|k7std|ddtjd|d|d|d tst|ja |jgtttrtj||ytttrtj|ytd ty) aSets the seed for generating random numbers for the calling rank. Args: seed (int): The desired seed. device_mesh (:class:`DeviceMesh`): The device mesh to set the seed. Returns: None .. warning:: When calling this function, :func:`manual_seed` must be called from all ranks of the default ``ProcessGroup`` even if some ranks may not be a part of the ``device_mesh``, with the same ``seed`` value. If ``device_mesh`` is a sub-mesh and the calling rank is not a part of it, ``manual_seed`` will not set its GPU device's generator seed. Current implementation only supports a GPU device mesh. zEDTensor randomness only supports cuda/cuda-like device type, but got z"calling manual_seed function over z- but received different seed values on ranks:z seed on rank z is z, and seed on rank !Nz7Unknown type of cuda RNG state tracker: _rng_tracker = )rrNotImplementedErrordistget_world_sizeall_gather_object enumerateint RuntimeErrorget_rankrr get_coordinate isinstancer _manual_seed)rrr object_listrankobjects rr r 3s;$'{'>'>?M !ST_TkTkSl m  &4..00K;-!+. f 3v; 4[MAno 0TF:MdVSWX^W__`a  ,[-D-DE !!#/ l$< =  % %k4 8  &; <  % %d +I,X  0rceZdZdZddefdZedeeeffdZ ede fdZ e jddZ de fd Z d edefd Zd ed eddfd ZdefdZy)ra _RNGStateTracker stores Random Number Generator (RNG) state (a ByteTensor object) in a dict, mapping from a corresponding tag to each state tensor. It also provides a set of convenient utility methods to help access/modify the state tensors. The most important interface is _distribute_region which will be used when DTensor executes a random op (an operator that calls RNG). rc||_t||_|jr|jjs"t |j j di|_|jjg|_ d|_ y)Nz= instantiation requires the presence of CUDA/CUDA-like deviceT) _device_typer_device_handle is_availabler% __class____name___statescurrent_device_devices_use_distribute_region)selfrs r__init__z_RNGStateTracker.__init__os~'0=##(;(;(H(H(J>>**++hi +- ,,;;=> &*#rrc|jSN)r4r8s r rng_statesz_RNGStateTracker.rng_states{s ||rc|jSr;r7r<s rdistribute_region_enabledz*_RNGStateTracker.distribute_region_enableds***rNc||_yr;r?)r8values rr@z*_RNGStateTracker.distribute_region_enableds &+#rc||jvSr;)r=)r8names rrng_state_is_syncz"_RNGStateTracker.rng_state_is_syncst&&rrDc||jvr$t|jjd||j|ddj t j }t|jS)N does not have random state for rdtype r=r%r2r3viewtorchint64r$item)r8rD seed_tensors rget_seedz_RNGStateTracker.get_seedsr t &>>**++KD6R t,a277ekk7J ;##%&&rrctj|gjtj}tjdgjtj}tj||g|j |<y)Nr)rMtensorrLuint8catr=)r8rDrrP offset_tensors rset_seedz_RNGStateTracker.set_seeds\llD6*// <  aS)..u{{; % ; *F Grspeccyr;r8rXs r_distribute_regionz#_RNGStateTracker._distribute_regions rcuda)rN)r3 __module__ __qualname____doc__strr9propertyrrr=boolr@setterrEr$rQrWr r\rZrrrrfs +C +Df-+4++%%,&,'''S'S'HSHHH  { rceZdZdZddeffd ZdeddfdZejde fd Z d edefd Z d ed eddfd Z de ddfdZde deddfdZdeedeedefdZxZS)r z This subclass of ``_RNGStateTracker`` defines the default policy of how RNG states should be shared and synchronized among all ranks to respect the semantics of DTensor random operators. rct|||jjj |}t j |d|j d|jd<y)Nrcpu parallel-rng)superr9r0 get_rng_statetor broadcastr=)r8r rng_stater2s rr9zOffsetBasedRNGTracker.__init__sT %''557::;G  y!$*3,,u*='r parallel_seedrNc(|jd|y)Nri)rW)r8ros rr)z"OffsetBasedRNGTracker._manual_seeds nm4rrXc#K|jds td|jr|jd}|j |t j j|j|j5|jj|jd d|j|| dddydy#|j||wxYw#1swYyxYww)NrizlOffsetBasedRNGTracker requires the random state to be synchronized before entering into a distribute region!r)rEr%r@ get_offset_set_pre_op_offsetrMrandomfork_rngr6r/r0rr=_set_post_op_offset)r8rX old_offsets rr\z(OffsetBasedRNGTracker._distribute_regions%%n5<   ) )8J  # #D )&&t}}$BSBS&T ?##11$//.2QR?,,T:>  ? ? ,,T:>  ? ?s6BC4)C(,C0C(C4C%%C((C1-C4rDc||jvr$t|jjd||j|ddj t j }t|jS)NrGrHrIrK)r8rDrVs rrsz OffsetBasedRNGTracker.get_offsetsr t &>>**++KD6R .388u{{8K =%%'((roffsetc:||jvr$t|jjd||j|dd}t j |gj tj}t j||g|j|<y)NrGrrH) r=r%r2r3rMrSrLrTrU)r8rDrzrPrVs r set_offsetz OffsetBasedRNGTracker.set_offsets t &>>**++KD6R t,a2  fX.33EKK@ % ; *F Grc|j}|j}|j}|j}|J|Dcgc]}|dk\r||nd}}|Dcgc]}|dk\r|j |nd}}|j ||} t |} t|jD]Q\} } t| ts|j | } | j}| j||| ddd| |<Sddl m}|| }|jd}| |zdzd zd z}|j!d||zycc}wcc}w) a Set the starting RNG offset for current device's local shard before actual op execution. The pre_op_offset value should start from the current RNG offset and increment by the size of local shard until it reaches the size of the whole DTensor. For different ranks that hold the same DTensor shard, their pre_op_offset will be the same. Args: spec (:class:`DTensorSpec`): the spec of the DTensor object on which we prepare the offset for running random ops. Returns: None .. warning:: Note that, current implementation does not consider DTensor's continguity. Example: take a DTensor of shape [8, 16] as an example. Assume that the DTensor is placed on a device mesh with placements ([Shard(1), Replicate(), Shard(0)]), and the mesh is: [[[0, 1], [2, 3]], [[4, 5], [6, 7]]] ``spec.mesh.get_coordinate()`` provides the coordinate of the current rank in the mesh. For example, the coordinate of rank 5 is (1, 0, 1). Another concept to introduce besides rank coordinate is shard coordinate. Each rank holds a local shard of the DTensor. In the example, the DTensor is partitioned into 4 [4, 8] shards. The first shard has 2 replicas and rank 0 (coord (0, 0, 0)) and rank 2 (coord (0, 1, 0)) have 1 replica each. That being said, the local shard on rank 0 and rank 2 correspond to the same shard of the DTensor. To denote each DTensor shard, we use a shard coordinate (in the example, it will be a tuple (i, j) where shard (i, j) has the slice DTensor[4 * i : 4 * (i + 1), 8 * j : 8 * (j + 1)], 0 <= i < 2, 0 <= j < 2). Once we have rank coordinate and shard coordinate, we can calculate on each rank what shard of the DTensor the rank holds, with the help of dim_map. The dim_map of the above DTensor is [2, 0] so the shard coordinate of a rank with rank coord (x, y, z) is simply (z, x) by taking(rank_coord[dim_map[0]],rank_coord[dim_map[1]]). Following this calculation, rank 0 and rank 2 holds the shard of coord (0, 0); rank 1 and rank 3 holds the shard of coord (0, 1); rank 4 and rank 6 holds the shard of coord (1, 0); rank 5 and rank 7 holds the shard of coord (1, 1); The last value to calculate before obtaining the starting offset is the shard linear index. The starting offset for each rank will be its shard_linear_index * local_tensor_numel. NrF) return_offsetprodri)shapemeshdim_mapr'size_calc_shard_linear_idxlistr# placementsr(r dim_local_shard_size_on_dim#torch.distributed.tensor._ops.utilsrrsr|)r8rX dtensor_shaperr coordinatemesh_dim shard_coord shard_sizeshard_linear_idxlocal_size_on_rank_0idx placement mesh_dim_size shard_dimr local_sizecurrent_offset offset_incrs rrtz(OffsetBasedRNGTracker._set_pre_op_offsets^ yy,, ((* %%%IP =EHMJx q 8  IP B  (DEC  s EErxcx|j}ddlm}||}|dzdzdz}|jd||zy)aSets the RNG to a synchronized state after running the local random op. Every rank should set its RNG offset to `old_offset + DTensor.numel()` where old_offset is the offset before calling `set_pre_op_offset` i.e. the offset before running DTensor random ops. Args: spec (:class:`DTensorSpec`): the spec of the DTensor object on which we post-process the offset for running random ops. Returns: None rrrrriN)rrrr|)r8rXrxrrnumels rrwz)OffsetBasedRNGTracker._set_post_op_offset2sB <]#q 1$  U(:;rrrctd}d}tt|t|D]\}}|||zz }||z}|S)Nrr~)zipreversed)r8rrrshard_coord_striderrs rrz,OffsetBasedRNGTracker._calc_shard_linear_idxIsXXk2HZ4HI 'IC &8 8 8  $ &  ' rr])r3r_r`rarbr9r$r) contextlibcontextmanagerr r\rsr|rtrwrr __classcell__r2s@rr r s >C>5#5$5{*)s)s)HsHCHDHZF{ZFtZFx< <<<.  9  26s)    rr cdeZdZddeffd Z d dedefdZejde fdZ xZ S) rrcrt|||jj|jd<y)Ntensor-parallel-rng)rjr9r0rkr=)r8rr2s rr9z!TensorParallelRNGTracker.__init__Ws. %151D1D1R1R1T-.rtp_mesh base_seedc\|j}d}||z|z}|jd|y)Ni r)get_local_rankrW)r8rrtensor_parallel_rankMegatronMagicNumtensor_parallel_seeds rr)z%TensorParallelRNGTracker._manual_seed\s= '557 (+;;>RR +-ABrrXc#K|jds td|jrtjj |j |j5|jj|jd d|jj|jd< dddydy#|jj|jd<wxYw#1swYyxYww)NrzoTensorParallelRNGTracker requires the random state to be synchronized before entering into a distribute region!rr) rEr%r@rMrurvr6r/r0rr=rkr[s rr\z+TensorParallelRNGTracker._distribute_regionhs%%&;<<   ) )&&t}}$BSBS&T <##11OO$9:<++99;OO- < < ++99;OO- < rs'' H>: .2 h)*1zd40c0 0t0f3 3 lw ,w t'/'r