sh$8SrSSKJr SrSrSr"SS\5rg) zC A library written in CUDA Python for generating reduction kernels ) from_dtype cH^^^^^^^^ SSKJm TRSS9"U5m [S-m[[-mTRSS9UU 4Sj5mTRSS9UUU 4Sj5mTRSS9UUU 4Sj5mUUUUUUU 4S jnTRU5$) NrcudaT)devicec>TRRnU[-nU[-nXSS24nXU'TR5 [S-nU(a7XF:aXTnT "XuXF-5XT'TR5 US-nU(aM6gg)z( Compute reduction within a single warp N) threadIdxx _WARPSIZEsyncwarp) sm_partialsinittidwarpidlaneidsm_thiswidtholdr reduce_ops p/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/numba/cuda/kernels/reduction.pyinner_warp_reduction1_gpu_reduce_factory..inner_warp_reductions nn !yai( Q~o"+C1H"I MMO aKE ec>T RRnT RRnT RRnT RRnX5U--nUR nXV-n Xn [ Xy-X5Hn T"XU 5n M T R5 T "X*5 T R5 US:a(T"X#S4X#S-S45X#S4'T R5 US:XaT"USUS5X'gg)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_block5_gpu_reduce_factory..device_reduce_full_block(s*nn  em#xx~ju|T0ACQ(C1 [.  7"+KQ,?,7a ,C#EKQ  MMO !8' D(9;t;LMHO rcv>TRRnTRRnTRRnU[-nU[-nUR nTRRnXn XXg4'TR 5 US-[-U:a T"X)5 O=US:Xa7X&SS24n U[-n [SX- 5Hn T"U SX5U S'M TR 5 US:Xa=U[-S- [-n USn[SU 5Hn T"XU S45nM XU'gg)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 rr r!rr#r%r$)r&r'rrr(r)rrr#valuerbaser/num_active_warpsresultrrrs rdevice_reduce_partial_block8_gpu_reduce_factory..device_reduce_partial_block_s>nn   !yxxnn&+FN#  QJ) #d *  4{%ai0 )q$+.A!*71:wz!BGAJ/  !8 % 1A 5)C  &F1./"6q!t+<=0%UO rc>>TRRnTRR[T 4T S9nTR RT :Xa T"XU5 O T"XU5 U(a2US:Xa+TR RS:XaT "USU5US'gggg)a 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_initrrrr0r7 inner_sm_size max_blocksizenbtypers rgpu_reduce_block_strided5_gpu_reduce_factory..gpu_reduce_block_stridedsnnkk''M(B.4(6 ==??m + $SK @ '{ C qT]]__%9#HQK6HQK&:8r)numbarjitrr=) fnrArBrr0r7r?rr@rs ` @@@@@@@r_gpu_reduce_factoryrG s%b)IMM )M XXTX( XXTX4N4Nl XXTX)%)%V77, 88, --rc2\rSrSrSr0rSrSrSSjrSr g) 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. cXlg)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__Reduce.__init__s  rcURU4nX R;aURUnU$[UR[U55nX0RU'U$)N)rM_cacherGr)rNr:keykernels r_compileReduce._compilesWmmU" ++ [[%F ) 58IJF%KK  rNcSSKJn URS:wa [S5eUbUSUnURR U5nUR S:aU$URUR5n[[-nUR U-U-n UR U - n [X-[S-5n U n U (aU S- n URXRS9n U (aX{X4"USU U SU US5 U (aUSX4"XSXSUU (+5 U R S:aUSX4"XUS 5 UbUSSRU SSUS 9 gU S$) aPerforms 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 )shaper:TF)stream) rDrndim TypeErrorr:typer#rVr=rmin device_arraycopy_to_device)rNr&r#resrrZrrU blocksize size_full size_partial full_blockct partials_sizer's r__call__Reduce.__call__s(  88q=34 4  et*Cyy~~d# 88a<Ksyy) ) XX*i7 xx)+ 919q=A %  Q M$$= $J  2 3C O4<]l4K4848 :  1l* +C O,4],C,00<,< > ==1  1m+ ,Xu M ? G " "8BQ< " ? A; rrL)NNrr) __name__ __module__ __qualname____firstlineno____doc__rSrPrVrg__static_attributes__rrrIrIs F IrrIN)rmnumba.np.numpy_supportrrr=rGobjectrIrorrrrs0.  U.pbVbr