`i ddlmZddlmZmZmZmZddlZddlm Z ddlm Z ddl Z ddl m Z ddlmcmZddlmcmZddlmcmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd lm"Z"dd l#m$Z$ddlm%Z%ddlm&Z&ddlm'Z'ddlm(Z(ddlm)Z)Gdde j*j+j,Z-Gdde j*j+j.Z/dZ0dZ1Gdde Z2e'j3fde de4e5efde'j6de2fdZ7dS) )chain)AnyCallableIterableOptionalN) ArrayLike) DTypeLike)ndarrayDevice)Stream)get_current_stream)_chunk)_Chunk)_data_transfer) _Communicator) _elementwise) _index_arith)_modes) _reduction)_linalgceZdZdS)_MultiDeviceDummyMemoryN)__name__ __module__ __qualname__r/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/distributed/array/_array.pyrrsDrrc*eZdZedefdZdS)_MultiDeviceDummyPointerreturnc tdS)Nr selfs rdevicez_MultiDeviceDummyPointer.device!sbzzrN)rrrpropertyr r'rrrr!r! s9 Xrr!c t|}|j5tj|}t j|||}dddn #1swxYwYt|5t}t j||||||||}t|j |j ||cdddS#1swxYwYdSN) prevent_gc) rr'_creation_from_dataascontiguousarrayr _AsyncDatarecordr _transferrarrayready) src_devdst_devidx src_arraycomms src_streamsrc_data dst_streamcopieds r_make_chunk_asyncr<(s#G,,J  BB'9)DD !, z((**yBBBBBBBBBBBBBBBBBB ++')) ) 'NJ 'NJ11flFL#!)+++ ++++++++++++++++++s$>A!!A%(A%;ACCCct|5t}tj|}t ||||cdddS#1swxYwYdSr*)r rr,r1rr/)r3r4r5r6r7streamr;s r_make_chunk_syncr?7s JJ#%%$*955ffmmoosyIIIJJJJJJJJJJJJJJJJJJsAA$$A(+A(cXeZdZUdZeeeefed<e j ed<eee fed<eee fed<e j dfdeedfd ed eeeefd e j d eeee fd df fd Zdkfd ZdZed e j fdZed eefdZed eeeeedfffdZd eeeeffdZdeed dfdZdZd efdZdZ dZ!d eeeeffdZ"de j#d eeeeffdZ$de j d dfdZ%d e j d dfdZ&d eeefd dfd!Z' dld e(jfd$Z)d%Z*d&Z+d'Z,d(Z-d)Z.d*Z/d+Z0d,Z1d-Z2d.Z3d/Z4d0Z5d1Z6d2Z7d3Z8d4Z9d5Z:d6Z;d7Zd:Z?d;Z@d<ZAd=ZBdmd?ZCd@ZDdmdAZEdBZFdCZGdndDZHdEZIdFZJdGZKdHZLdIZMdJZNdKZOdLZPdMZQdNZRdOZSdPZTdQZUdRZVdSZWdodTZXdUZYdVZZdWZ[dXZ\dYZ]dZZ^d[Z_d\Z`d]Zad^Zbed_Zced`ZdedaZeedbZfedcZgeddZhedeZiedfZjedgZkefdhZleljmdiZledjZnxZoS)pDistributedArraya __init__(self, shape, dtype, chunks_map, mode=REPLICA, comms=None) Multi-dimensional array distributed across multiple CUDA devices. This class implements some elementary operations that :class:`cupy.ndarray` provides. The array content is split into chunks, contiguous arrays corresponding to slices of the original array. Note that one device can hold multiple chunks. This direct constructor is designed for internal calls. Users should create distributed arrays using :func:`distributed_array`. Args: shape (tuple of ints): Shape of created array. dtype (dtype_like): Any object that can be interpreted as a numpy data type. chunks_map (dict from int to list of chunks): Lists of chunk objects associated with each device. mode (mode object, optional): Mode that determines how overlaps of the chunks are interpreted. Defaults to ``cupyx.distributed.array.REPLICA``. comms (optional): Communicator objects which a distributed array hold internally. Sharing them with other distributed arrays can save time because their initialization is a costly operation. .. seealso:: :attr:`DistributedArray.mode` for details about modes. _chunks_map_mode_streams_commsNshape.dtype chunks_mapmoder7r"ctd}t|d}t||||}||_||_i|_||ni|_|S)Nr)memptr)rr!super__new__rBrCrDrE) clsrFrGrHrIr7memrKobj __class__s rrMzDistributedArray.__new__bsh &a(()#q11ggooc5%o??$  #/UUR  rc:tj|i|dSN)rL__init__)r&argskwargsrQs rrTzDistributedArray.__init__ts%$)&)))))rc(|tddS)NzIDistributed array can only be instantiated by an explicitconstructor call) RuntimeError)r&rPs r__array_finalize__z#DistributedArray.__array_finalize__ws% ?#$$ $ ?rc|jS)a Describe how overlaps of the chunks are interpreted. In the replica mode, chunks are guaranteed to have identical values on their overlapping segments. In other modes, they are not necessarily identical and represent the original data as their max, sum, etc. :class:`DistributedArray` currently supports ``cupyx.distributed.array.REPLICA``, ``cupyx.distributed.array.MIN``, ``cupyx.distributed.array.MAX``, ``cupyx.distributed.array.SUM``, ``cupyx.distributed.array.PROD`` modes. Many operations on distributed arrays including :class:`cupy.ufunc` and :func:`~cupyx.distributed.array.matmul` involve changing their mode beforehand. These mode conversions are done automatically, so in most cases users do not have to manage modes manually. Example: >>> A = distributed_array( ... cupy.arange(6).reshape(2, 3), ... make_2d_index_map([0, 2], [0, 1, 3], ... [[{0}, {1, 2}]])) >>> B = distributed_array( ... cupy.arange(12).reshape(3, 4), ... make_2d_index_map([0, 1, 3], [0, 2, 4], ... [[{0}, {0}], ... [{1}, {2}]])) >>> C = A @ B >>> C array([[20, 23, 26, 29], [56, 68, 80, 92]]) >>> C.mode 'sum' >>> C.all_chunks() {0: [array([[0, 0], [0, 3]]), # left half array([[0, 0], [6, 9]])], # right half 1: [array([[20, 23], [56, 65]])], # left half 2: [array([[26, 29], [74, 83]])]} # right half >>> C_replica = C.change_mode('replica') >>> C_replica.mode 'replica' >>> C_replica.all_chunks() {0: [array([[20, 23], [56, 68]]), # left half array([[26, 29], [80, 92]])], # right half 1: [array([[20, 23], [56, 68]])], # left half 2: [array([[26, 29], [80, 92]])]} # right half )rCr%s rrIzDistributedArray.mode}s pzrc4|jS)z4A collection of device IDs holding part of the data.)rBkeysr%s rdeviceszDistributedArray.devicess$$&&&rcHd|jDS)zz9DistributedArray.index_map...s666eek666rr)rcdevchunkss r z.DistributedArray.index_map..s====C66v666===r)rBitemsr%s r index_mapzDistributedArray.index_maps2==#'#3#9#9#;#;=== =rci}|jD]I\}}g||<|D]<}||j|||j=J|S)zReturn the chunks with all buffered data flushed. Buffered data are created in situations such as resharding and mode changing. )rBriflushrCappendr1)r&rHrfrgrds r all_chunkszDistributedArray.all_chunkss 02 +1133 4 4KC JsO 4 4 DJ'''3&&u{3333 4rr]c|j|z}||jst j||_||jz D]?}t|5t|j|<dddn #1swxYwY@dSrS) rBr\issubsetrEr_create_communicatorsrDr r )r&r]rfs r_prepare_comms_and_streamsz+DistributedArray._prepare_comms_and_streamss"''))G3 0 0 2 233 H(>wGGDKT]//111 . .C . .%+XX c" . . . . . . . . . . . . . . . . .sB22B6 9B6 c.tj|||SrS)r_execute)r&kernelrUrVs r$__cupy_override_elementwise_kernel__z5DistributedArray.__cupy_override_elementwise_kernel__s$VT6:::rc|td|td|rtdtj||||S)Nzaxis must be specifiedzArgument `out` is not supportedz$Argument `keepdims` is not supported)rXrrt)r&ruaxisrGoutkeepdimss r"__cupy_override_reduction_kernel__z3DistributedArray.__cupy_override_reduction_kernel__s[ <788 8 ?@AA A  GEFF F"4u===rcT|jdkr|dkrtj|i|StS)Nmatmul__call__)rrr}NotImplemented)r&ufuncmethodinputsrVs r__array_ufunc__z DistributedArray.__array_ufunc__s4 >X % %&J*>*>>64V44 4rcdt|trtj||StSrS) isinstancerArr}r)xys r __matmul__zDistributedArray.__matmul__s- a) * * ">!Q'' '! !rc<i}|jD]\}}d|D||<|jtjurX||jtj|j|j ||j |j |S)Nc6g|]}|Sr)copyrbs rrezEDistributedArray._copy_chunks_map_in_replica_mode..s @@@uzz||@@@r) rBrirCrREPLICArrr\r_all_reduce_intersectionsrFrErD)r&rHrfrgs r _copy_chunks_map_in_replica_modez1DistributedArray._copy_chunks_map_in_replica_modes +1133 A AKC@@@@@JsOO :V^ + +  + +D,<,A,A,C,C D D D  , DJ DK P P Prop_modec>|}tj|D]!}|t j"ttj|}||j }tt|D]V}||}t|dzt|D]+}||} | | j |j|,W|S)N)rr from_iterablevaluesrlrrlist identity_ofrGrangelenset_identity_on_intersectionrarF) r&rrHrd chunks_listidentityia_chunkjb_chunks r_copy_chunks_map_in_op_modez,DistributedArray._copy_chunks_map_in_op_modes::<< ():):)<)<== ( (E KK ' ' ' '5.z/@/@/B/BCCDD &&tz22 s;''(( 9 9A!!nG1q5#k"2"233 9 9%a.44M4:x9999 9 rc|j|ur|St|jdkru|j\}t|dkrG|d|jt |j|j|j||jS|tj ur| }n|J| |}t |j|j|||jS)Nrr) rCrrBrrlrArFrGrErrrr)r&rrgrHs r _to_op_modezDistributedArray._to_op_modes : K t A % %&--//GF6{{aq  +++'J D,<T[*** fn $ $>>@@JJ&&&99'BBJ J JFF Frc,||S)zReturn a view or a copy in the given mode. Args: mode (mode Object): How overlaps of the chunks are interpreted. .. seealso:: :attr:`DistributedArray.mode` for details about modes. )r)r&rIs r change_modezDistributedArray.change_mode3s%%%rrjc tj|j|}||jkr|S|j}i}|D]\}}g||<|D]t}t |5tj|j|}tj |||} || | dddn #1swxYwYu| | tj|D]} | |j|jt$jur| } tj|D]/} | | |j|j|j|j0t1|j|j||j|jS)a"Return a view or a copy having the given index_map. Data transfers across devices are done on separate streams created internally. To make them asynchronous, transferred data is buffered and reflected to the chunks when necessary. Args: index_map (dict from int to array indices): Indices for the chunks that devices with designated IDs own. The current index_map of a distributed array can be obtained from :attr:`DistributedArray.index_map`. N)r_normalize_index_maprFrjrBrir _shape_after_indexingrcreate_placeholderrmrrr\rrrrlrCrrrapply_torErDrArG) r&rj new_index_mapold_chunks_mapnew_chunks_maprfidxsr5 dst_shape new_chunk src_chunk dst_chunks rreshardzDistributedArray.reshard?s#%9 J ## DN * *K)24',,.. : :IC"$N3  : :C[[:: , B C!)!)I & 9)S# N NI"3'..y999 ::::::::::::::: : '' (8(8999,^-B-B-D-DEE 0 0I OODJ ' ' 'z//%NN,, "01F1F1H1HII 0 0 ""tz4:K0000 0  J NDJ MM Ms"A B::B> B> CTc|td|dkrtd|tdtj|jD]}||j|jtjur!tj |j |j }n?|j |j }tj|j ||j }tj|}tj|jD]}|j|j}|jtjurt'j|j||<R|j||t'j|j||||j S)z.Return a copy of the array on the host memory.NzArgument `stream` not supportedrzArgument `order` not supportedzArgument `out` not supported)rG)rXrrrBrrlrCrrnumpyemptyrFrGrfull atleast_1dr2 synchronizeracupyasnumpyr1 numpy_funcreshape) r&r>orderryblockingrdnp_arrayrr5s rgetzDistributedArray.getxs  @AA A C<<?@@ @ ?=>> >()9)@)@)B)BCC $ $E KK # # # # : ' '{4:TZ@@@HHz--dj99Hz$*h CCH#H--()9)@)@)B)BCC M ME K # # % % %+CzV^++ $ U[ 9 9  %%SM4< #<#@@ @rc td)rz0DistributedArray currently does not support any.rrs ranyzDistributedArray.anyrrc td)rz3DistributedArray currently does not support argmax.rrs rargmaxzDistributedArray.argmax! ACC Crc td)rz3DistributedArray currently does not support argmin.rrs rargminzDistributedArray.argminrrc td)rz9DistributedArray currently does not support argpartition.rrs r argpartitionzDistributedArray.argpartition! GII Irc td)rz4DistributedArray currently does not support argsort.rrs rargsortzDistributedArray.argsortrrc td)rz3DistributedArray currently does not support astype.rrs rastypezDistributedArray.astyperrc td)rz3DistributedArray currently does not support choose.rrs rchoosezDistributedArray.chooserrc td)rz1DistributedArray currently does not support clip.rrs rclipzDistributedArray.clip! ?AA Arc td)rz5DistributedArray currently does not support compress.rrs rcompresszDistributedArray.compressrrc td)rz1DistributedArray currently does not support copy.rrs rrzDistributedArray.copyrrc td)rz4DistributedArray currently does not support cumprod.rrs rcumprodzDistributedArray.cumprodrrc td)rz3DistributedArray currently does not support cumsum.rrs rcumsumzDistributedArray.cumsumrrc td)rz5DistributedArray currently does not support diagonal.rrs rdiagonalzDistributedArray.diagonalrrc td)rz0DistributedArray currently does not support dot.rrs rdotzDistributedArray.dotrrc td)rz1DistributedArray currently does not support dump.rrs rdumpzDistributedArray.dumprrc td)rz2DistributedArray currently does not support dumps.rrs rdumpszDistributedArray.dumps! @BB Brc td)rz1DistributedArray currently does not support fill.rrs rfillzDistributedArray.fill rrc td)rz4DistributedArray currently does not support flatten.rrs rflattenzDistributedArray.flattenrrc td)rz1DistributedArray currently does not support item.rrs ritemzDistributedArray.itemrrFcH|tj|d||S)a"Return the maximum along a given axis. .. note:: Currently, it only supports non-``None`` values for ``axis`` and the default values for ``out`` and ``keepdims``. .. seealso:: :meth:`cupy.ndarray.max`, :meth:`numpy.ndarray.max` N)r{ _statisticsamaxr&rxryrzs rmaxzDistributedArray.max*66  dD#x99 9rc td)rz1DistributedArray currently does not support mean.rrs rmeanzDistributedArray.mean*rrcH|tj|d||S)a"Return the minimum along a given axis. .. note:: Currently, it only supports non-``None`` values for ``axis`` and the default values for ``out`` and ``keepdims``. .. seealso:: :meth:`cupy.ndarray.min`, :meth:`numpy.ndarray.min` N)r{raminrs rminzDistributedArray.min/rrc td)rz4DistributedArray currently does not support nonzero.rrs rnonzerozDistributedArray.nonzero=rrc td)rz6DistributedArray currently does not support partition.rrs r partitionzDistributedArray.partitionB! DFF Frc|#|tj||||S|tj||||S)a$Return the minimum along a given axis. .. note:: Currently, it only supports non-``None`` values for ``axis`` and the default values for ``out`` and ``keepdims``. .. seealso:: :meth:`cupy.ndarray.prod`, :meth:`numpy.ndarray.prod` )r{_mathprod_auto_dtypeprod_keep_dtyper&rxrGryrzs rprodzDistributedArray.prodGs] =::%tUCCC C::%tUCCC Crc td)rz0DistributedArray currently does not support ptp.rrs rptpzDistributedArray.ptpYrrc td)rz0DistributedArray currently does not support put.rrs rputzDistributedArray.put^rrc td)rz2DistributedArray currently does not support ravel.rrs rravelzDistributedArray.ravelcrrc td)rz9DistributedArray currently does not support reduced_view.rrs r reduced_viewzDistributedArray.reduced_viewhrrc td)rz3DistributedArray currently does not support repeat.rrs rrepeatzDistributedArray.repeatmrrc td)rz4DistributedArray currently does not support reshape.rrs rrzDistributedArray.reshaperrrc td)rz2DistributedArray currently does not support round.rrs rroundzDistributedArray.roundwrrc td)rz8DistributedArray currently does not support scatter_add.rrs r scatter_addzDistributedArray.scatter_add|rrc td)rz8DistributedArray currently does not support scatter_max.rrs r scatter_maxzDistributedArray.scatter_maxrrc td)rz8DistributedArray currently does not support scatter_min.rrs r scatter_minzDistributedArray.scatter_minrrc td)rz9DistributedArray currently does not support searchsorted.rrs r searchsortedzDistributedArray.searchsortedrrc td)rz0DistributedArray currently does not support set.rrs rsetzDistributedArray.setrrc td)rz1DistributedArray currently does not support sort.rrs rsortzDistributedArray.sortrrc td)rz4DistributedArray currently does not support squeeze.rrs rsqueezezDistributedArray.squeezerrc td)rz0DistributedArray currently does not support std.rrs rstdzDistributedArray.stdrrc|#|tj||||S|tj||||S)a"Return the minimum along a given axis. .. note:: Currently, it only supports non-``None`` values for ``axis`` and the default values for ``out`` and ``keepdims``. .. seealso:: :meth:`cupy.ndarray.sum`, :meth:`numpy.ndarray.sum` )r{rsum_auto_dtypesum_keep_dtypers rsumzDistributedArray.sums] =::$dE3BB B::$dE3BB Brc td)rz5DistributedArray currently does not support swapaxes.rrs rswapaxeszDistributedArray.swapaxesrrc td)rz1DistributedArray currently does not support take.rrs rtakezDistributedArray.takerrc td)rz5DistributedArray currently does not support toDlpack.rrs rtoDlpackzDistributedArray.toDlpackrrc td)rz4DistributedArray currently does not support tobytes.rrs rtobyteszDistributedArray.tobytesrrc td)rz3DistributedArray currently does not support tofile.rrs rtofilezDistributedArray.tofilerrc td)rz3DistributedArray currently does not support tolist.rrs rtolistzDistributedArray.tolistrrc td)rz2DistributedArray currently does not support trace.rrs rtracezDistributedArray.tracerrc td)rz6DistributedArray currently does not support transpose.rrs r transposezDistributedArray.transposer rc td)rz0DistributedArray currently does not support var.rrs rvarzDistributedArray.varrrc td)rz1DistributedArray currently does not support view.rrs rviewzDistributedArray.viewrrc td)rz.DistributedArray currently does not support T.rr%s rTzDistributedArray.Ts" <>> >rc td)rz1DistributedArray currently does not support base.rr%s rbasezDistributedArray.base" ?AA Arc td)rz4DistributedArray currently does not support cstruct.rr%s rcstructzDistributedArray.cstruct" BDD Drc td)rz1DistributedArray currently does not support data.rr%s rdatazDistributedArray.datarMrc td)rz3DistributedArray currently does not support device.rr%s rr'zDistributedArray.devices" ACC Crc td)rz2DistributedArray currently does not support flags.rr%s rflagszDistributedArray.flagss" @BB Brc td)rz1DistributedArray currently does not support flat.rr%s rflatzDistributedArray.flat rMrc td)rz1DistributedArray currently does not support imag.rr%s rimagzDistributedArray.imagrMrc td)rz1DistributedArray currently does not support real.rr%s rrealzDistributedArray.realrMrc*tjS)zTuple of array dimensions. Assignment to this property is currently not supported. .. seealso: :attr:`cupy.ndarray.shape`, :attr:`numpy.ndarray.shape` )rLrF)r&rQs rrFzDistributedArray.shapesww}rc td)Nz@DistributedArray currently does not support assignment to shape.r)r&newshapes rrFzDistributedArray.shape)s! NPP Prc td)rz4DistributedArray currently does not support strides.rr%s rstrideszDistributedArray.strides.rPr)r"N)NrNT)NNF)NNNN)NNNF)prrr__doc__dictintrr__annotations__rModer rrtupler rrMrTrYr(rIrr]slicerjr rnrrrvrr{rrr_OpModerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrr r"r$r&r(r*r,r.r0r4r6r8r:r<r>r@rBrDrFrHrJrLrOrRr'rUrWrYr[rFsetterr` __classcell__)rQs@rrArA>s<c4<'(((( ;3; m# $$$$ #N48 #s(O,5d6l*+kS-/01   $******$$$ 7fk777X7r'#'''X'=4T%s *;%< <====X= Dd7m!34     .(3- .D . . . .;;; >9< > > > > """ $sDL7H2I    !>.23V 3D.E0F6;F3EFFFF( & &0B & & & &7Mc3h7M4F7M7M7M7Mt:>!,!, !,!,!,!,NHHH HHH DDD EEE EEE @@@ @@@ CCC CCC III DDD CCC CCC AAA EEE AAA DDD CCC EEE @@@ AAA BBB AAA DDD AAA 9 9 9 9AAA 9 9 9 9DDD FFF CCCC$@@@ @@@ BBB III CCC DDD BBB HHH HHH HHH III @@@ AAA DDD @@@ BBBB$EEE AAA EEE DDD CCC CCC BBB FFF @@@ AAA >>X> AAXA DDXD AAXA CCXC BBXB AAXA AAXA AAXA X \PP\PDDXDDDDDrrAr1rjrIr"c t|trl|j|kr||}|j|kr||}t|j|j|j|j |j St|tj tfr%|tjkr|}ntj|}t#j|j|}d}t|trJ|jj}||jjhz}t-j|}t0}n d}t2}i}|D]s\}} g||<| D]f} || } |||| | |} ||| |tjur$|js||j|| <gtt|j|j|||S)alCreates a distributed array from the given data. This function does not check if all elements of the given array are stored in some of the chunks. Args: array (array_like): :class:`DistributedArray` object, :class:`cupy.ndarray` object or any other object that can be passed to :func:`numpy.array`. index_map (dict from int to array indices): Indices for the chunks that devices with designated IDs own. One device can have multiple chunks, which can be specified as a list of array indices. mode (mode object, optional): Mode that determines how overlaps of the chunks are interpreted. Defaults to ``cupyx.distributed.array.REPLICA``. .. seealso:: :attr:`DistributedArray.mode` for details about modes. Example: >>> array = cupy.arange(9).reshape(3, 3) >>> A = distributed_array( ... array, ... {0: [(slice(2), slice(2)), # array[:2, :2] ... slice(None, None, 2)], # array[::2] ... 1: (slice(1, None), 2)}) # array[1:, 2] Nr$)rrArIrrjrrFrGrBrCrErr rrrr1rrr'idr\rrqr<r?rirm idempotentr) r1rjrIr7r3r] make_chunkrHrfrr5 chunk_arrayrds rdistributed_arrayrp5s@%)** :  %%d++E ?i ' 'MM),,E Ke&7 L %%-122# 6> ! !JJLLE E""1%+yIII E%!!&,/..""elo%664W==& % *,J__&& ; ; T 3 ; ;C*KJwS+uEEE sO " "5 ) ) )FN** O+!--ek::c  ;  U[*dE ; ;;r)8 itertoolsrtypingrrrrr numpy.typingrr rcupy._core.corer cupy._creation.from_data _creation from_datar,cupy._core._routines_math_core_routines_mathrcupy._core._routines_statistics_routines_statisticsrcupy.cuda.devicer cupy.cuda.streamr rcupyx.distributed.arrayrcupyx.distributed.array._chunkrr&cupyx.distributed.array._data_transferrrrrrrcudamemoryMemoryr MemoryPointerr!r<r?rArrbrcrerprrrrs444444444444 """""""""""" ######666666666)))))))))555555555############//////******111111222222@@@@@@000000000000******......++++++     di.5   ty/= + + +JJJt Dt Dt Dt Dt Dwt Dt Dt DtN;N; N;CH~N; +N; N;N;N;N;N;N;r