J/Ph$@dZddlmZdZdZdZGddeZdS) zC A library written in CUDA Python for generating reduction kernels ) from_dtype c ddlmd| tdzttzd fdd fdd fd fd }|S) NrcudaT)devicec0jj}|tz}|tz}||ddf}|||<tdz}|rC||kr ||} ||||z||<|dz}|AdSdS)z8 Compute reduction within a single warp N) threadIdxx _WARPSIZEsyncwarp) sm_partialsinittidwarpidlaneidsm_thiswidtholdr reduce_ops \/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/cuda/kernels/reduction.pyinner_warp_reductionz1_gpu_reduce_factory..inner_warp_reductions n !yfaaai( Q ~~fo"+)C%1H"I"I MMOOO aKE      c jj} jj} jj} jj}|||zz}|j}||z} ||} t || z|| D]} | || }   ||  |dkr8||df||dzdf||df< |dkr|d|d||<dSdS)a Partially reduce `arr` into `partials` using `sm_partials` as working space. The algorithm goes like: array chunks of 128: | 0 | 128 | 256 | 384 | 512 | block-0: | x | | | x | | block-1: | | x | | | x | block-2: | | | x | | | The array is divided into chunks of 128 (size of a threadblock). The threadblocks consumes the chunks in roundrobin scheduling. First, a threadblock loads a chunk into temp memory. Then, all subsequent chunks are combined into the temp memory. Once all chunks are processed. Inner-block reduction is performed on the temp memory. So that, there will just be one scalar result per block. The result from each block is stored to `partials` at the dedicated slot. r rrr)r rN) r rblockIdxblockDimgridDimsizerange syncthreadsr)arrpartialsrrblkidblkszgridszstartstopsteptmpirrrs rdevice_reduce_full_blockz5_gpu_reduce_factory..device_reduce_full_block(sD*n  eem#xv~%jut|T400 ) )A)CQ((CC [#...  77"+)KQ,?,7a ,C#E#EKQ  MMOOO !88'i D(9;t;LMMHUOOO 8rcjj}jj}jj}|tz}|tz}|j}jj}||} | |||f<|dztz|kr || nM|dkrG||ddf} |tz} td|| z D]} | d| | | d<|dkrK|tzdz tz} |d}td| D]} ||| df}|||<dSdS)z This computes reduction on `arr`. This device function must be used by 1 threadblock only. The blocksize must match `arr.size` and must not be greater than 128. r rNr)r rrr rr"r$r#)r%r&rrr'r(rrr"valuerbaser.num_active_warpsresultrrrs rdevice_reduce_partial_blockz8_gpu_reduce_factory..device_reduce_partial_block_sn   !yxnC&+ FFN#  QJ) #d * * e 4 4 4 4{{%faaai0 )q$+..CCA!*71:wqz!B!BGAJJ  !88 % 1A 5)C  &F1.// > >"6;q!t+<==$HUOOO 8rc"jj}jt f }jj kr|||n ||||r-|dkr)jjdkr |d||d<dSdSdSdS)aJ Perform reductions on *arr* and writing out partial reduction result into *partials*. The length of *partials* is determined by the number of threadblocks. The initial value is set with *init*. Launch config: Blocksize must be multiple of warpsize and it is limited to 4 warps. )dtyperN)r rsharedarray _NUMWARPSr r) r%r&ruse_initrrrr/r5 inner_sm_size max_blocksizenbtypers rgpu_reduce_block_stridedz5_gpu_reduce_factory..gpu_reduce_block_stridedsnk''M(B.4(66 =?m + + $ $S(K @ @ @ @ ' 'X{ C C C  7qT]_%9%9#)HQK66HQKKK 7 7%9%9r)numbarjitrr:) fnr>r?rr/r5r<rr=rs ` @@@@@@@r_gpu_reduce_factoryrC sT%%%b))IMM )M XXTX( XXTX4N4N4N4N4N4N4Nl XXTX)%)%)%)%)%)%)%V77777777777, 88, - --rc*eZdZdZiZdZdZddZdS)ReducezCreate a reduction object that reduces values using a given binary function. The binary function is compiled once and cached inside this object. Keeping this object alive will prevent re-compilation. c||_dS)z :param functor: A function implementing a binary operation for reduction. It will be compiled as a CUDA device function using ``cuda.jit(device=True)``. N)_functor)selffunctors r__init__zReduce.__init__s   rc|j|f}||jvr|j|}n,t|jt|}||j|<|S)N)rG_cacherCr)rHr7keykernels r_compilezReduce._compilesSmU" $+  [%FF( 58I8IJJF%DK  rNrcddlm}|jdkrtd| |d|}|j|}|jdkr|S||j}ttz}|j|z|z} |j| z } t| |ztdz} | } | r| dz } | | |j} | r'|| ||f|d| | d| |d| r(|d| |f|| d| | d|| | jdkr|d| |f| | |d |)|dd | dd| dS| dS) a'Performs a full reduction. :param arr: A host or device array. :param size: Optional integer specifying the number of elements in ``arr`` to reduce. If this parameter is not specified, the entire array is reduced. :param res: Optional device array into which to write the reduction result to. The result is written into the first element of this array. If this parameter is specified, then no communication of the reduction output takes place from the device to the host. :param init: Optional initial value for the reduction, the type of which must match ``arr.dtype``. :param stream: Optional CUDA stream in which to perform the reduction. If no stream is specified, the default stream of 0 is used. :return: If ``res`` is specified, ``None`` is returned. Otherwise, the result of the reduction is returned. rrr zonly support 1D arrayNr )shaper7TF)stream) r@rndim TypeErrorr7typer"rOr:rmin device_arraycopy_to_device)rHr%r"resrrRrrN blocksize size_full size_partial full_blockct partials_sizer&s r__call__zReduce.__call__s(  8q==344 4  ete*Cy~~d## 8a<<Ksy)) ) X*i7 x)+ 9 19q=AA %   Q M$$= $JJ  : 3F<F2 3C  O4<]l]4K4848 : : :  > +F1lF* +C O,4\]],C,00<,< > > > =1   ,F1mV+ ,Xxu M M M ? G " "8BQB< " ? ? ? FA; r)NNrr)__name__ __module__ __qualname____doc__rLrJrOr_rrrErEs] F   IIIIIIrrEN)rcnumba.np.numpy_supportrrr:rCobjectrErdrrrgs.-----  U.U.U.pbbbbbVbbbbbr