U ?hF@sddlZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!ddlm"Z"m#Z#m$Z$ddlm%Z%ddl&m'Z(ddl)Z*ddl+Z+ddl,ZdZ-d d Z.d d Z/Gd dde0Z1ddZ2Gddde0Z3d7ddZ4ddZ5ddZ6ddZ7ddZ8ddZ9dd Z:d!d"Z;d#d$Zd8d*d+Z?d,d-Z@d.d/ZAd0d1ZBe Cd2Gd3d4d4e jDZEd5d6ZFdS)9N)typestypingerrorsirrewritesconfigir_utils)internal_prange) next_labeladd_offset_to_labels replace_vars remove_dels rename_labelsfind_topo_ordermerge_adjacent_blocksGuardExceptionrequireguardget_definition find_callnamefind_build_sequenceget_np_ufunc_typget_ir_of_code simplify_CFGcanonicalize_array_mathdead_code_elimination)compute_cfg_from_blockscompute_use_defscompute_live_variables)postproc)empty_inferredTcCsH|jD]8}|tjD]&}t|jtjrd}tj ||j dqq dS)z8Checks the IR of a callee is supported for inlining z-The use of yield in a closure is unsupported.locN) blocksvalues find_instsrAssign isinstancevalueYieldrUnsupportedErrorr")func_irblkstmtmsgr/O/var/www/html/venv/lib/python3.8/site-packages/numba/core/inline_closurecall.pycallee_ir_validator,s r1cCs:|d|}|dddd}|dddd}|S)aCreates a name for an inlined variable based on the function name and the variable name. It does this "safely" to avoid the use of characters that are illegal in python variable names as there are occasions when function generation needs valid python name tokens..<_>$_v)replace)Z function_namevar_name inlined_namenew_namer/r/r0_created_inlined_var_name6sr<c@sNeZdZdZidfddZddZddZd d Zd d Zd dZ ddZ dS)InlineClosureCallPasszInlineClosureCallPass class looks for direct calls to locally defined closures, and inlines the body of the closure function to the call site. FcCs"||_||_||_g|_||_dSN)r+parallel_optionsswapped_processed_stencilstyped)selfr+r?r@rBr/r/r0__init__Is zInlineClosureCallPass.__init__c st|j}|dd}t|jj}td}|d|r|\}}t |j D]\}}t |t j rT|j} t | t jrT| jdkrTtt|j| } tt|j| j} t|j|||| | rd}q:t|j|||| rd}q:t|j|| | rTd}qTq:tr|rt|jjt|jj} |dt| | fddD} g}t| d d dd D]>\}}||tt |j| |||j!|j"j#|j$rXd}qX|rt%|j|rt|jj} | &D]}|jj|=qt'|jt(|jj|j_t)|jj|d d S)z&Run inline closure call pass. TFr=ZSTARTcallzstart inline arraycallcsg|]}|t|jfqSr/)lenbody).0kloopsr/r0 |sz-InlineClosureCallPass.run..cSs|dS)Nr/)tupr/r/r0z+InlineClosureCallPass.run..)keyreverseENDN)*rZ PostProcessorr+runlistr#items_make_debug_printpop enumeraterGr'rr&r(Exproprrrfunc_inline_reduction_inline_closure_inline_stencilenable_inline_arraycallrr _debug_dumprKkeyssortedappend_inline_arraycallr@r? comprehensionrB_fix_nested_arrayZ dead_nodesrrr )rCppmodified work_list debug_printZ_labelblockiinstrexpr call_namefunc_defcfgZ sized_loopsvisitedrIsZdeadr/rJr0rTPs              zInlineClosureCallPass.runc Csxt|jj t|dkp|dkt|jdkr8tdt|j|jdd dd}t|j|jj j j ||||t dd S) N)reducebuiltins)ru _functools)z^invalid reduce call, two arguments are required (optional initial value can also be specified)rcSs6t|}|dk r|}nt|}|D]}|||}q"|Sr>)iternext)fAvitrtar/r/r0 reduce_funcs z.reduce_funcrjcallee_validatorT)N) rr?Z reductionrFargs TypeErrorcheck_reduce_funcr+inline_closure_callfunc_idr\ __globals__r1)rCrjrlrmrorprr/r/r0r]s$   z'InlineClosureCallPass._inline_reductionc Csxddlm}|j}|j}t|tjrb|jdkrbt|j|rb|jrT|j|jj7_n |jj|_dSt |dkpr|dkt ||j k|j |t |j dkstdtt|j|j d}t t|tjo|jd kt|jjjj|j}t|j} d | krt|j| } | std d | kr:t|j| } | s:td ||d| } |j| _td| |j} | g|jj|j<| |_dS)Nr) StencilFuncstencilT)rznumba.stencils.stencil)rnumbarMz5As a minimum Stencil requires a kernel as an argument make_function neighborhoodzXstencil neighborhood option should be a tuple with constant structure such as ((-w, w),) index_offsetszYstencil index_offsets option should be a tuple with constant structure such as (offset, )Zconstant)Znumba.stencils.stencilrtargetr(r'rGlobalnamekwsrrArdrFr ValueErrorrrr+rZr[rrr\rcodedict_fix_stencil_neighborhood_fix_stencil_index_offsetsr" _definitions) rCrnrprqrlhsroZ stencil_defZ kernel_iroptionsZfixedZsfZ sf_globalr/r/r0r_sZ             z%InlineClosureCallPass._inline_stencilcCsht|j|d}tt|dg}|jD].}t|j|}tt|d|t|jq(t||d<dS)z Extract the two-level tuple representing the stencil neighborhood from the program IR to provide a tuple to StencilFunc. rrVT)rr+rhasattrrVrdtuple)rCrZdims_build_tupleresZ window_varZwin_build_tupler/r/r0rs   z/InlineClosureCallPass._fix_stencil_neighborhoodcCs0t|j|d}tt|dt|j|d<dS)z Extract the tuple representing the stencil index offsets from the program IR to provide to StencilFunc. rrVT)rr+rrrrV)rCrZ offset_tupler/r/r0rsz0InlineClosureCallPass._fix_stencil_index_offsetsc Cs>tt|tjo|jdkt|j|jjjj ||||t ddS)NrrT) rr'rrZr[rr+rr\rr1)rCrjrlrmrqr/r/r0r^s z%InlineClosureCallPass._inline_closureN) __name__ __module__ __qualname____doc__rDrTr]r_rrr^r/r/r/r0r=DsK2 r=cCstt||}|dkrtdt|tjtjfrRt|jtj j j sHtd|jj }nt |dsnt |dsntdt |dr~|jn|j}|jdkstd|S)zsChecks the function at func_var in func_ir to make sure it's amenable for inlining. Returns the function itselfNzMReduce function cannot be found for njit analysiszInvalid reduction functionr__code__rxz*Reduction function should take 2 arguments)rrrr'rFreeVarrr(rcoreregistryZ CPUDispatcherZpy_funcrrr co_argcountr)r+func_varrf_coder/r/r0rs(    rc@sPeZdZdZdddddeddfddZdddZdddZdd d Zd d Z dS) InlineWorkera= A worker class for inlining, this is a more advanced version of `inline_closure_call` in that it permits inlining from function type, Numba IR and code object. It also, runs the entire untyped compiler pipeline on the inlinee to ensure that it is transformed as though it were compiled directly. Nc Csdd} ddlm} ||||f} dd| D} t| rht| sh| |d| |d| |d | |d nt| rz| |d | j|_||_||_||_||_ ||_ ||_ t d |_ ||f} d d| D}t|rt|sd}t|| t| |_||_||_dS)a1 Instantiate a new InlineWorker, all arguments are optional though some must be supplied together for certain use cases. The methods will refuse to run if the object isn't configured in the manner needed. Args are the same as those in a numba.core.Compiler.state, except the validator which is a function taking Numba IR and validating it for use when inlining (this is optional and really to just provide better error messages about things which the inliner cannot handle like yield in closure). cSs|dkrtd|dS)Nz{} must not be None)rformat)argrr/r/r0check@sz$InlineWorker.__init__..checkr)DefaultPassBuildercSsg|] }|dk qSr>r/rHxr/r/r0rLIsz)InlineWorker.__init__.. targetctxlocalspipelineflags typingctxrcSsg|] }|dkqSr>r/rr/r/r0rL_szKtypemap and calltypes must both be either None or have a value, got: %s, %sN)numba.core.compilerranyallZdefine_untyped_pipeline_compiler_pipelinerrrrr validatorrWrkr!_permit_update_type_and_call_mapstypemap calltypes)rCrrrrrrrrrrZ compiler_argsZcompiler_grouppairZ pair_is_noner.r/r/r0rD.s6          zInlineWorker.__init__cCsdd}||}|jdk r$||||}|j} |j|} | j} |j} ttjt|j } t | | d} t | } | |_t | }t| } tj | |dt|t| }|d|t|dkst|d}i}t|jjD]H}|j|krt|jj|j}| j||jd}|j||jd|||j<q|d |t| ||d t||jj}t| ||j|j|}|j r|dkrt!d |"|||j} |d t|t#| |g}t$%| |j}|j|dd|_t&}||j|<|'||f|jd||_|j't$(|| jt)| }t*| | j+|| j+j|j,kr| |j,| j+jkr|j,| j+j-| |D]6}| |}| |_t.||||j|<|'||fq|d t||| ||fS)a Inlines the callee_ir in the caller_ir at statement index i of block `block`, callee_freevars are the free variables for the callee_ir. If the callee_ir is derived from a function `func` then this is `func.__code__.co_freevars`. If `arg_typs` is given and the InlineWorker instance was initialized with a typemap and calltypes then they will be appropriately updated based on the arg_typs. cSsn|}i|_|jD]P\}}t|j|}g|_|j|jD]}t|}|j|qB||j|<q|Sr>)copyr#rVdeepcopyrGrd)Zthe_irZ kernel_copyZ block_labelrl new_blockr-Zscopyr/r/r0copy_irss  z'InlineWorker.inline_ir..copy_irNrM After relabelcallee_scopes = rr! var_dict = After local var renamez%arg_typs should have a value not NoneAfter arguments rename: After merge in)/rscoperGr(r#maxr_the_max_labelr{rbr rminupdaterkra_get_all_scopesrFAssertionErrorr localvars_conr$rr<r unique_nameredefiner"r r\_get_callee_argsrrupdate_type_and_call_maps_replace_args_withrBlockr rdJumpr_replace_returnsrrremove_add_definitions)rC caller_irrlrm callee_irZcallee_freevarsarg_typsrZcallee_ir_originalrrn call_expr callee_blocks max_label min_label callee_scopes callee_scopevar_dictvarr:new_varZ callee_funcr new_blocksr new_label topo_orderlabelr/r/r0 inline_irhs                        zInlineWorker.inline_ircCs(||}|jj}|j||||||dS)a Inlines the function in the caller_ir at statement index i of block `block`. If `arg_typs` is given and the InlineWorker instance was initialized with a typemap and calltypes then they will be appropriately updated based on the arg_typs. )r)run_untyped_passesr co_freevarsr)rCrrlrmfunctionrrZfreevarsr/r/r0inline_functions  zInlineWorker.inline_functionFc Csddlm}m}ddlm}ddlm}ddlm}|}d|_ |j |_ |j |_ |j |_ |j |_ |j|_||j_|j||_d|_d|_d|_|d|_d|_||_i|_||t|jjjjtj f|_!|"|} | #| $||j S)a& Run the compiler frontend's untyped passes over the given Python function, and return the function's canonical Numba IR. Disable SSA transformation by default, since the call site won't be in SSA form and self.inline_ir depends on this being the case. r) StateDict_CompileStatus)ExtractByteCode)bytecode)ParforDiagnosticsNF)%rrrZnumba.core.untyped_passesr numba.corernumba.parfors.parforrr+rrrrr enable_ssaZFunctionIdentity from_functionrrrZtype_annotationstatus return_typeZparfor_diagnosticsmetadataZrun_passrFbcpysig parametersrZpyobjectrrfinalizerT) rCr\rrrrrrstatepmr/r/r0rs4       zInlineWorker.run_untyped_passesc Csddlm}ddlm}|js*d}t|ddlm}t |j |_ t j j||||}t |j |_ ||j|j||d\}}} } ||}t |j |_ t||| |jdd|D} | D]} || q|j||j| dS) z_ Updates the type and call maps based on calling callee_ir with arguments from arg_typsr)reconstruct_ssa)PreLowerStripPhisz_InlineWorker instance not configured correctly, typemap or calltypes missing in initialization. typed_passesNcSsg|]}|dr|qSzarg. startswithrHZvnamer/r/r0rL7s z:InlineWorker.update_type_and_call_maps..)Znumba.core.ssarZnumba.core.typed_passesrrrrrrbuild_definitionsr#rrranalysisdead_branch_prunetype_inference_stagerrZ_strip_phi_nodesrrXrrr) rCrrrrr.r f_typemapZ_f_return_type f_calltypesr4 arg_namesrr/r/r0rs@      z&InlineWorker.update_type_and_call_maps)N)N)F) rrrrr1rDrrrrr/r/r/r0r&s ;  *rc - s|j} |j|}|j}td}|d|d|t|dr<|jn|j}t|drR|jn|j}t |t j rddl m }|j|dd }n t||}| d k r| ||j}ttjt|j}t||d }t|}||_t|}t|}tj||d t|t|}|d |t|d ks.t|d}i}|jj D]>}|j!|j"krFt#|j$j%|j!}| j&||j'd}|||j!<qF|d|t(|||dt|t)|||j|j'|}|dt||r| r|*|}|d|t |t+r.t,j-j.t,j/_0t,j/f_1t+fdd|D} n$t |t2j3rH|j4dksLt|j5} t|j"t| ksjtt6|| |dt||rJddl m7}!t8|j|_9t:j;j<=||z|!>||||d \}"}#}$}%Wn0t?k r|!>||||d \}"}#}$}%YnXt@||"|$|dd|"D}&|&D]}'|"A|'q$||"| |$tB||g}(t2C| |j'})|j|d d |)_tD}*|)|j|*<|(E|*|)f|jd ||_|jEt2F||j'tG|}+tH||jI|*|jIj!|j9kr ||j9|jIj!kr |j9|jIj!J||+D]6},||,}| |_tK||||j|,<|(E|,|fq|dt|| d k rx|(D]}| E|qf||fS)aInline the body of `callee` at its callsite (`i`-th instruction of `block`) `func_ir` is the func_ir object of the caller function and `glbls` is its global variable environment (func_ir.func_id.func.__globals__). `block` is the IR block of the callsite and `i` is the index of the callsite's node. `callee` is either the called function or a make_function node. `typingctx`, `typemap` and `calltypes` are typing data structures of the caller, available if we are in a typed pass. `arg_typs` includes the types of the arguments at the callsite. `callee_validator` is an optional callable which can be used to validate the IR of the callee to ensure that it contains IR supported for inlining, it takes one argument, the func_ir of the callee Returns IR blocks of the callee and the variable renaming dictionary used for them to facilitate further processing of new blocks. rzFound closure call: z with callee = rclosurer)compilerT)Zinline_closuresNrMrrr!rrrzcallee's closure = c3s|]}|VqdSr>r/rZcellgetr/r0 sz&inline_closure_call.. build_tuplezAfter closure renamercSsg|]}|dr|qSrrr r/r/r0rLs z'inline_closure_call..r)LrrGr(rWrrrr __closure__r'pytypes FunctionTyperrZ run_frontendrr#rrrr{rbr rrrrarrFrrrr$rrr<rrrr"r rrrctypesZ pythonapiZ PyCell_GetZ py_objectrestypeZargtypesrrZr[rV_replace_freevarsrr rrrr r r ExceptionrrXrrr rdrrrrrr)-r+ZglblsrlrmcalleerrrrrrjrZreplace_freevarsrrnrrkZ callee_codeZcallee_closurerrrrrrrrrr:rrrrVrrZ f_return_typerr4rrrrrrrr/rr0r>s                        rcs|jdkr.t|j}|jrfd}t||jn8|jdkrB|jg}n$t |rV| }nt d |jt d}t|tjrtjj|}dd}fdd} d d } |jdkrt|j} ni} tjj||| || | St|d r|jn|j} | r|d | t| trPg} | D]4}t|tjr.| |n| tj |d q|| }nrt| tjsjt| t!r"| }t|tj#st$|jdkst$fdd|j%D}||}nt&d | |SdS)zGet arguments for calling 'callee', including the default arguments. keyword arguments are currently only handled when 'callee' is a function. rEz,Calling a closure with *args is unsupported.getattrzUnsupported ir.Expr.{}z$inline_closure_call default handlingcSs|Sr>r/indexparamdefaultr/r/r0rOrPz"_get_callee_args..cs t|Sr>)rConstr r!r/r0rOrPcSstd||dS)Nz.Stararg not supported in inliner for arg {} {})NotImplementedErrorrr r/r/r0stararg_handlers z)_get_callee_args..stararg_handlerdefaultsz defaults = r(r"rcsg|]}|qSr/rrr+r/r0rLsz$_get_callee_args..z)Unsupported defaults to make_function: {}N)'r[rUrvarargrr*r"r(rZis_operator_or_getitem list_varsrrrWr'rrrrutilsZ pysignaturerrrZfold_argumentsrr' __defaults__rrVarrdr$strrrZrrVr%)rrr"r+rr.rkrZnormal_handlerZdefault_handlerr&rZcallee_defaultsZ defaults_listrZ default_tupleZ const_valsr/)r+r"r0rsn                 rcsfdd}|S)Ncs*tjr&tdddd|DdS)Nz: css|]}t|VqdSr>)r0rr/r/r0r%sz9_make_debug_print..debug_print..)rDEBUG_INLINE_CLOSUREprintjoin)rprefixr/r0rk#sz&_make_debug_print..debug_printr/)r6rkr/r5r0rW"s rWcCstjr|dSr>)rr2dumpr*r/r/r0ra)sracCs0g}|D]\}}|j|kr ||jq |S)z+Get all block-local scopes from an IR. )rVrrd)r#Z all_scopesrrlr/r/r0r.s  rcCs\|D]N\}}|tj}|D]4}t|jtjr |jj}|t|ksJt |||_q qdS)z@ Replace ir.Arg(...) with real arguments from call site N) rVr%rr&r'r(ZArgr!rFrr#rrrlassignsr-idxr/r/r0r8s rcCs|D]t\}}|tj}|D]Z}t|jtjr |jj}|t|ksJt t||tj rf|||_q t |||j |_q qdS)zJ Replace ir.FreeVar(...) with real variables from parent function N) rVr%rr&r'r(rr!rFrr/r$r"r8r/r/r0rEs  rc Cs|D]\}}g}tt|jD]}|j|}t|tjr|dt|jksRtt|j ||j |j|<|j t ||j |D]}|j j|j jkr|j j |_ qq"t|tjr"t|j tjr"|j jdkr"| |q"qdS)zN Return return statement by assigning directly to target, and a jump. rMcastN)rVrangerFrGr'rReturnrr&r(r"rdrrrrZr[) r#rZ return_labelrrlZcastsrmr-r;r/r/r0rUs"     rcCs4|j}|tj}|D]}||jj|jqdS)zF Add variable definitions found in a block to parent func_ir. N)rr%rr&rrrdr()r+rlZ definitionsr9r-r/r/r0rks rc Cs2d}d}d}d}|t|jkr|j|}t|tjrT|r|r|j|jkrd}qnt|tjr|j}|j}t t ||dkrt|j dtj r|j d}|}|} t |j} nRt|tjrt|jtj r|s|j}|j}t||} tt t|| |} i} nq|d}qt|o|td|j| || | fS)zLook for statement like "x = numpy.array(y)" or "x[..] = y" immediately after the closure call that creates list y (the i-th statement in block). Return the statement index if found, or raise GuardException. NFrT)arraynumpyrMZfind_array_call)rFrGr'rDelr(rr&rrrrr/rrSetItemrr_find_unsafe_empty_inferredrW) r+rl array_varZlist_var_dead_after_array_calllist_varrmrnrroZarray_stmt_index array_kwsZ array_defr/r/r0_find_arraycallusJ         rFc CsZtd}t||}|d|d|tt|tjo6|jdk|j}t||}|d|d|tt|tjon|jdk|j}t||}|d|d |tt|tj o|jt kp|jt j j jkt|j} d |jjg} | d kr | ||jj<t||jd d d} d |jd |fS| dkrR| ||jj<t||jd d d} t||jd d d} | | |fStdS)zzFind the iterator's actual range if it is either range(n), or range(m, n), otherwise return raise GuardException. Zfind_iter_rangezrange_iter_var =  def = Zgetiterz range_var = z range_def = rEz func_var = z func_def = )z"array comprehension"z closure ofrMrTZlhs_onlyrxN)rWrrr'rrZr[r(r\rr<rmiscspecialZprangerFrr"rr) r+Zrange_iter_varr@rkZrange_iter_defZ range_var range_defrrqnargsZswappingstopstartr/r/r0_find_iter_ranges:           rOFc< std}tt|jdktt|j}t||j|\} } } d} d} d| krtt| dt j t || d} tt| t j o| j dkt || j} t || }|d| d|t|t j r|j dkrt ||j}tt|t j o|j d ktt|jd kg}|jD]}fd d ||D}t|s0q|j|}|d ||t jD]}|j}t|t j rP|j dkrPt ||j}t|t j rP|j dkrP|jdkrPt ||j}|d|||k||krP||||fqPqtt|dk|d \}}}tdd||jD}|d||jt|gBt||jt|gBkg}g}|j|j}|t jD]b}|j}t|t j rl|j dkrt ||j}|d|||jn|j dkrl||jqltt|dkot|dk|d }|d } tt|jdk|jtt|j}!|!j}"|!j}#|!j}$g}%g}&dd}'t t|!jdD]P}(|!j|(}t|t jr|j|ks|'|j|&r|&|jn |%|qX|d|&t!t"|||})|##d|$}*|)r|)d d kr| }*n|%t$||*t j%d|$d|$|##d|$}+|)rj|)\},}-}.|,d kr2|-}/nt j j&t'j(|-|,|$d}/|rt|.t j)rd|._*t+|._nZ|r|##d |$}0d d!l,m-}1|%t$||0t j)d"|1|$d#|$t j j.|0|fd$|$d#}/nt/|%t$||+|/|$|##d%|$}2|%t$||2t j j0|+g|$d&|$|##d'|$}3|##d(|$}4| r| r|##d)|$}5|##d|$}6|%t$||5| |$|%t$||6t j 1|5| j|$|$|%t$||4t j)d*t2j3|$d#|$d|6fg} n0|r|%t$||4t j)d+t4|$d#|$g} nt/|%t$||3t j j.|4|2ft5| |$d#|$|&D]}7|%t$||7|3|$q|%|"|%|!_|)r|)d d kr<|j}"t|"t j6s\t7|"j8}8|j|8}9|9j}$|9j9d t$||*t j j&t'j(| |)d |$d|$n|j}$|j}"|jd d}%|##d,|$}:|##d-|$};|%t$||;t j%d|$d|$|%t$||:t j j&t'j:|*|;|$d|$|%t$||*|:|$|%|"|%|_t t|jD]@}(|j|(|krJ|d.t j;|3|*|jj.zcheck loop body block rErdz list_def = css|]\}}|VqdSr>r/)rHrSbr/r/r0rsz$_inline_arraycall..zpreds = Ziternextz iter_def = Z pair_firstcSs,t|tjr(|D]}|j|jkrdSqdS)NTF)r'rr/r)valremovedrr/r/r0 is_removed<s   z%_inline_arraycall..is_removedzremoved variables: r!r(size)fnrrhsr"r Zlen_func)length_of_iteratorr]r!r/ size_tuplerVr"r> empty_funcZ dtype_modemptyunsafe_empty_inferredZ next_indexonezReplace append with SetItem)rr!r(r"T)>rWrrFZexitsr{rzrFr#r'rr/rrZr[r(rVrGZin_loopsrr%r&r\attrrdsetZ predecessorsrRentriesr terminatorrr"r<rrOr_new_definitionr$Zbinopoperatorsubrrr Znumba.cpython.rangeobjr]rErrrnprarbrUZBranchrZtruebrinsertaddrArr).csPt|}td||t|tjrHtt|r4|S|jdkrH|jSt dS)zFind numpy array definition such as arr = numba.unsafe.ndarray.empty_inferred(...). If it is arr = b[...], find array definition of b recursively. find_array_defgetitemN) rrWr'rrZrrBr[r(r)ZarrZarr_def)rtr+r/r0rts     z)_fix_nested_array..find_array_defcsltd}D]P\}}|j}|j}t}tt|D]&}||} t| tj r8| | j j | j |kr8g} |D]} | j |ks| j |kr| j j|kr|| j d| | qr|| j dt| j } t| tjrN| j} |d| }t| j | }t||| }g}||d||||||d||_| |qrtqr| Sq8qtdS)zDouble check if all variables in varlist are defined before expr is used. Try to move constant definition when the check fails. Bails out by raising GuardException if it can't be moved. fix_dependenciesz already definedz not yet definedrN)rWrVrrGrer<rFr'rr&rmrrr(defmaprdrr$r"rrhextendr)roZvarlistrkrrlrrGZdefinedrminstZ new_varlistrZvar_defr"rZ new_constZ new_vardefnew_body)r#r+livemapusedefsr/r0rvsP           z+_fix_nested_array..fix_dependenciescstt|tjtt|jtjtd}|d||j}|}|d|t|j}|d|tt|tj |j dkrt|j}tt|tj tt |t|j d}tt|tj o|j dk|d|fd d |j D}|d |t|j d}tt|tj o |j dk|d |||}|j |7_ d |_ tj|_t|dd|_|j|_|jd=|jd=|jd=|jd=dS)aFor assignment like lhs[idx] = rhs, where both lhs and rhs are arrays, do the following: 1. find the definition of rhs, which has to be a call to numba.unsafe.ndarray.empty_inferred 2. find the source array creation for lhs, insert an extra dimension of size of b. 3. replace the definition of rhs = numba.unsafe.ndarray.empty_inferred(...) with rhs = lhs[idx] fix_array_assignzfound SetItem: zfound lhs_def: zfound rhs_def: r;rrz dim_def = csg|]}t|ddqS)TrHr)rr*r/r0rLMsz?_fix_nested_array..fix_array_assign..z extra_dims = zsize_tuple_def = ruTrHr\rr+r)rr'rrAr(r/rWrrrZr[rBrrVrirur[r!Z_kws)r-rkrZlhs_defZrhs_defZdim_defZ extra_dimsZsize_tuple_def)rtrvr+r/r0r}0sJ            z+_fix_nested_array..fix_array_assignN) r#rrrrbrrwrrGrr)r+rrZ empty_deadmapr}rrlr-r/)r#rtrvr+r{r|r0rgs-3   rgcCs|g|j|j<tj|||dS)N)r(rr")rrrr&)r+rr(r"r/r/r0rhjsrhzafter-inferencecs0eZdZdZfddZddZddZZS)RewriteArrayOfConstszThe RewriteArrayOfConsts class is responsible for finding 1D array creations from a constant list, and rewriting it into direct initialization of array elements without creating the list. cs|j|_tt|j||dSr>)rsuperr~rD)rCrrr __class__r/r0rDuszRewriteArrayOfConsts.__init__cCs6t|dkrdS||_tt|||j|||_|jdk S)NrF)rF crnt_blockr_inline_const_arraycallrrz)rCr+rlrrr/r/r0matchys zRewriteArrayOfConsts.matchcCs|j|j_|jSr>)rzrrGrCr/r/r0applys zRewriteArrayOfConsts.apply)rrrrrDrr __classcell__r/r/rr0r~os r~c s.td|jfdd}Gdddt}|}|jD]}t|tjr"t|jtjr|jj |j kr|j |j j |j |q@nt|jtjr|j} | jdkr|dd| jD|_|j j g|_ |j |q@n:| jd kr| krt||j | |j |j |jrd |_q@nt|tjr|j} | |jkrR|j |q@n| |j kr|j | |j | |j ||j gkrg} |j D]N}t|tjr|j j |jkst|tjr|j|jkrڐq| |q| |_ g|_d |_q@|j |||r@|q@|jr*|j Sd S) a|Look for array(list) call where list is a constant list created by build_list, and turn them into direct array creation and initialization, if the following conditions are met: 1. The build_list call immediate precedes the array call; 2. The list variable is no longer live after array call; If any condition check fails, no modification will be made. Zinline_const_arraycallc stt|}t|o(|ddko(|ddkt|jdj|k|j}tt|tjo`|j dk|j }|jd}|j} d|d|| j } t |\} } t | } d|}d|}tj}t|d}||j<||j<|t|tj| |d ||t|tjj|g|d |t| }d |}ttj}||fd |i||j<|t|tjd tj|d |d|}tjt|j<tdt|}|t|||d|}||j<t| }|dkrd}tj |||}|t|||tjj!|||gi|d }t"#| |||<|t|||t$| D]r}d|}tj}||j<|t|t|||t%||| ||}t"#tj&| || |<||q\|'|dS)zCheck to see if the given "array_var" is created from a list of constants, and try to inline the list definition as array initialization. Extra statements produced with be appended to "stmts". rMr?rr>zinline array_var = z list_var = rZr^r!r_r`rPraz $np_g_varrkz $np_typ_varboolZbool_r!T)(rrrrrrr'rZArrayCompatiblendimr"rPrrFrZintpZUniTuplerdrhrr$rZrZDTyperrkraZresolve_function_typerrIModuler0rrEr signaturer<rAnonerx)rCrorpr,delsZcallnameZret_typer"rDZ array_typrPseqr4rZrrrsZsize_typZsize_tuple_typZnptyper`ZfntyZg_np_varZg_npZtyp_varZ dtype_strZnp_typ_getattrZ empty_callrmrqZ index_typsetitemrcontextrkr+rrr/r0 inline_arrays                        z-_inline_const_arraycall..inline_arrayc@s(eZdZdZddZddZddZdS) z&_inline_const_arraycall..Statez This class is used to hold the state in the following loop so as to make it easy to reset the state of the variables tracking the various statement kinds cSs(g|_g|_g|_g|_g|_d|_dS)NF)r, dead_vars list_itemsrprrirr/r/r0rDs z/_inline_const_arraycall..State.__init__cSsg|_g|_g|_g|_dS)zV Resets the internal state of the variables used for tracking N)r,rrrrr/r/r0resetsz,_inline_const_arraycall..State.resetcstfdd|DS)z Returns True if the list being analysed is used between the build_list and the array call. csg|]}|jjkqSr/)rr,rrr/r0rLszH_inline_const_arraycall..State.list_var_used..)rr,)rCryr/rr0 list_var_usedsz4_inline_const_arraycall..State.list_var_usedN)rrrrrDrrr/r/r/r0States rrQcSsg|] }|jqSr/)rrr/r/r0rL&sz+_inline_const_arraycall..rETN)rWrobjectrGr'rr&r(r/rr,rdrrprZr[rrVrrrrir@rrr) rlr+rrrrrrryroZ removed_varrGr/rr0rsr`'                    r)NNNNNNNT)FF)GrrrrZnumba.core.analysisrrrrrrrrrr Znumba.core.ir_utilsr r r r rrrrrrrrrrrrrrrrrrZnumba.np.unsafe.ndarrayr rbr?rkriZnumba.misc.specialr`r1r<rr=rrrrrWrarrrrrrFrOrerBrgrhZregister_rewriteZRewriter~rr/r/r/r0sh$ P   K  E   1"