+
    &ja+                         ^ RI t ^ RIt^ RIHtHtHtHtHtHt ^ RI	H
t
 RRR/R lltRR ltRR ltRR ltRRR/R	 lltRRR/R
 lltR# )    N)_flatten_dense_tensors_get_device_index_handle_complex_reorder_tensors_as_take_tensors_unflatten_dense_tensors)nccloutc               "   \        V 4      p VRJ VRJ ,          '       g   \        RV RV 24      hVe:   V Uu. uF  p\        V4      NK  	  pp\        P                  P                  W4      # \        P                  P                  W4      # u upi )a  Broadcasts a tensor to specified GPU devices.

Args:
    tensor (Tensor): tensor to broadcast. Can be on CPU or GPU.
    devices (Iterable[torch.device, str or int], optional): an iterable of
      GPU devices, among which to broadcast.
    out (Sequence[Tensor], optional, keyword-only): the GPU tensors to
      store output results.

.. note::
    Exactly one of :attr:`devices` and :attr:`out` must be specified.

Returns:
    - If :attr:`devices` is specified,
        a tuple containing copies of :attr:`tensor`, placed on
        :attr:`devices`.
    - If :attr:`out` is specified,
        a tuple containing :attr:`out` tensors, each containing a copy of
        :attr:`tensor`.
NzFExactly one of 'devices' and 'out' must be specified, but got devices=z	 and out=)r   RuntimeErrorr   torch_C
_broadcast_broadcast_out)tensordevicesr
   ds   &&$ n/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/torch/nn/parallel/comm.py	broadcastr      s    * V$F_--TU\T]]fgjfkl
 	
 189A$Q'9xx""633 xx&&v33	 :s   Bc                    V Uu. uF  p\        V4      NK  	  ppV  Uu. uF  p\        V4      NK  	  p p\        P                  P	                  WV4      # u upi u upi )a  Broadcast a sequence of tensors to the specified GPUs.

Small tensors are first coalesced into a buffer to reduce the number of synchronizations.

Args:
    tensors (sequence): tensors to broadcast. Must be on the same device,
      either CPU or GPU.
    devices (Iterable[torch.device, str or int]): an iterable of GPU
      devices, among which to broadcast.
    buffer_size (int): maximum size of the buffer used for coalescing

Returns:
    A tuple containing copies of :attr:`tensor`, placed on :attr:`devices`.
)r   r   r   r   _broadcast_coalesced)tensorsr   buffer_sizer   ts   &&&  r   broadcast_coalescedr   2   sV     .55W #WG5+237aq!7G388((;GG 63s
   AAc           	     *   \        VRR7      pV ^ ,          P                  4       pRp\        V 4       F  w  rEVP                  P                  R8X  d   \        RV R24      hVP                  4       V8X  d   TpVP                  4       V8w  g   K]  RP                  R VP                  4        4       4      pRP                  R	 V 4       4      p\        R
V RV RV 24      h	  Vf   \        R4      h\        V 4      ^8X  d
   V ^ ,          # \        P                  ! V 4      '       d7   \        P                  ! W,          4      p\        P                  ! WVR7       V# \        P                  ! W,          P                  P                  V4      p	\        V 4       UU
u. uF  w  rJWC8w  g   K  V
NK  	  ppp
W,          V^ ,          P!                  V	RR7      ,           pVR,           F%  pVP#                  VP!                  V	RR7      4       K'  	  V# u up
pi )a  Sum tensors from multiple GPUs.

All inputs should have matching shapes, dtype, and layout. The output tensor
will be of the same shape, dtype, and layout.

Args:
    inputs (Iterable[Tensor]): an iterable of tensors to add.
    destination (int, optional): a device on which the output will be
        placed (default: current device).

Returns:
    A tensor containing an elementwise sum of all inputs, placed on the
    :attr:`destination` device.
T)optionalNcpuz7reduce_add expects all inputs to be on GPUs, but input z
 is on CPUxc              3   8   "   T F  p\        V4      x  K  	  R # 5iNstr.0r   s   & r   	<genexpr>reduce_add.<locals>.<genexpr>`   s     6:a3q66:   c              3   8   "   T F  p\        V4      x  K  	  R # 5ir!   r"   r$   s   & r   r&   r'   a   s     ;
1A
r(   zinput z has invalid size: got z, but expected zLreduce_add expects destination to be on the same GPU with one of the tensors)outputroot)devicenon_blocking:   NN)r   size	enumerater,   typeAssertionError
get_devicejoin
ValueErrorr   lenr	   is_availabler   
empty_likereducetoadd_)inputsdestination
input_size
root_indexiinpgotexpectedresultdestination_devicer   nonrootothers   &&           r   
reduce_addrH   F   s    $K$?K!JJF#::??e# I!JW  >>{*J88:#((6388:66Cxx;
;;H23%xjQ  $ Z
 	
 6{aay  !!&"45F
; M #\\&*<*C*C*H*H+V!*6!2F!2ao11!2F#gajmm%D '4 '
 
 R[[EKK(:NO !M Gs   
H+Hc                R   V  Uu. uF  p. NK  	  pp. p. p\        V RR/  F  p\        ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       d7   \        Wq4      pVP                  V4       VP                  V^ ,          4       Ks  \        WGRR7       F8  w  rT	P                  V
P                  '       d   V
P                  4       MT
4       K:  	  VP                  V^ ,          R,          4       K  	  V Uu. uF  p\        W4      NK  	  pp\        VRR/  F]  pV Uu. uF  p\        V4      NK  	  pp\        W4      p\        VV^ ,          4       F  p
VP                  V
P                  4       K   	  K_  	  \        \        WV4      4      # u upi u upi u upi )a,  Sum tensors from multiple GPUs.

Small tensors are first coalesced into a buffer to reduce the number
of synchronizations.

Args:
    inputs (Iterable[Iterable[Tensor]]): iterable of iterables that
        contain tensors from a single device.
    destination (int, optional): a device on which the output will be
        placed (default: current device).
    buffer_size (int): maximum size of the buffer used for coalescing

Returns:
    A tuple of tensors containing an elementwise sum of each group of
    inputs, placed on the ``destination`` device.
strictTc              3   8   "   T F  qP                   x  K  	  R # 5ir!   )	is_sparse)r%   r   s   & r   r&   'reduce_add_coalesced.<locals>.<genexpr>   s     3Nq{{Nr(   F)rJ   )zipallrH   appendrL   to_denser   r   r   datatupler   )r<   r=   r   _dense_tensorsr*   	ref_ordertensor_at_gpusrD   collr   r   itrschunkschunkflat_tensorsflat_results   &&&              r   reduce_add_coalescedr_   |   sr   & .4 4VVM 4FIv3d333N33333N333<FMM&!^A./}TJAKKKAJJLQ? K]1-b12 4 @MM}GM'/}DMt)D)7=
7=e"5)v 	 
 !;)+vayAA MM!&&!	 B * $V7883 !5 N
s   FF,F$c          	     L   \        V 4      p VfE   V Uu. uF  p\        V4      NK  	  pp\        \        P                  P                  WW#V4      4      # Ve   \        RV 24      hVe   \        RV 24      h\        \        P                  P                  WW44      4      # u upi )a  Scatters tensor across multiple GPUs.

Args:
    tensor (Tensor): tensor to scatter. Can be on CPU or GPU.
    devices (Iterable[torch.device, str or int], optional): an iterable of
      GPU devices, among which to scatter.
    chunk_sizes (Iterable[int], optional): sizes of chunks to be placed on
      each device. It should match :attr:`devices` in length and sums to
      ``tensor.size(dim)``. If not specified, :attr:`tensor` will be divided
      into equal chunks.
    dim (int, optional): A dimension along which to chunk :attr:`tensor`.
      Default: ``0``.
    streams (Iterable[torch.cuda.Stream], optional): an iterable of Streams, among
      which to execute the scatter. If not specified, the default stream will
      be utilized.
    out (Sequence[Tensor], optional, keyword-only): the GPU tensors to
      store output results. Sizes of these tensors must match that of
      :attr:`tensor`, except for :attr:`dim`, where the total size must
      sum to ``tensor.size(dim)``.

.. note::
    Exactly one of :attr:`devices` and :attr:`out` must be specified. When
    :attr:`out` is specified, :attr:`chunk_sizes` must not be specified and
    will be inferred from sizes of :attr:`out`.

Returns:
    - If :attr:`devices` is specified,
        a tuple containing chunks of :attr:`tensor`, placed on
        :attr:`devices`.
    - If :attr:`out` is specified,
        a tuple containing :attr:`out` tensors, each containing a chunk of
        :attr:`tensor`.
zI'devices' must not be specified when 'out' is specified, but got devices=zQ'chunk_sizes' must not be specified when 'out' is specified, but got chunk_sizes=)r   r   rT   r   r   _scatterr   _scatter_out)r   r   chunk_sizesdimstreamsr
   r   s   &&&&&$ r   scatterrf      s    D V$F
{189A$Q'9UXX&&v'RSS[\c[de  "cdocpq  UXX**6EFF :s   B!c               P   V  Uu. uF  p\        V4      NK  	  p pVfS   VR8X  d   \        P                  ! R\        ^R7       \	        VRRR7      p\
        P                  P                  WV4      # Ve   \        RV 24      h\
        P                  P                  WV4      # u upi )a^  Gathers tensors from multiple GPU devices.

Args:
    tensors (Iterable[Tensor]): an iterable of tensors to gather.
      Tensor sizes in all dimensions other than :attr:`dim` have to match.
    dim (int, optional): a dimension along which the tensors will be
      concatenated. Default: ``0``.
    destination (torch.device, str, or int, optional): the output device.
      Can be CPU or CUDA. Default: the current CUDA device.
    out (Tensor, optional, keyword-only): the tensor to store gather result.
      Its sizes must match those of :attr:`tensors`, except for :attr:`dim`,
      where the size must equal ``sum(tensor.size(dim) for tensor in tensors)``.
      Can be on CPU or CUDA.

.. note::
    :attr:`destination` must not be specified when :attr:`out` is specified.

Returns:
    - If :attr:`destination` is specified,
        a tensor located on :attr:`destination` device, that is a result of
        concatenating :attr:`tensors` along :attr:`dim`.
    - If :attr:`out` is specified,
        the :attr:`out` tensor, now containing results of concatenating
        :attr:`tensors` along :attr:`dim`.
zjUsing -1 to represent CPU tensor is deprecated. Please use a device object or string instead, e.g., "cpu".)
stacklevelT)	allow_cpur   zQ'destination' must not be specified when 'out' is specified, but got destination=rN   )
r   warningswarnFutureWarningr   r   r   _gatherr   _gather_out)r   rd   r=   r
   r   s   &&&$ r   gatherro      s    4 ,337aq!7G3
{"MM@	 (tdSxxk::"cdocpq  xx##G#66! 4s   B#r!   )   )Nrp   )NNr   N)r   N)rj   r   torch._utilsr   r   r   r   r   r   
torch.cudar	   r   r   rH   r_   rf   ro        r   <module>ru      sU       44 4DH(3l,9^0GPT 0Gf*7D *7rt   