U 9%e k@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddlm Z ddl mZddlmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZddl Z ddl!Z ddl"m#m Z$ddl m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-m.Z.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6dd l7m8Z8m9Z9m:Z:m;Z;dd lZ>ddl?m@Z@eZAeZBe+e*e)fZCeDeEZFGdddeGZHddlIZIddlJmKZKddlLmMZMe jNjOjPZPdddddddddddddd d!gZQedd"d#ZRdaSGd$d%d%eGZTGd&ddZUd'dZVd(dZWd)d*ZXd+dZYd,d-ZZee[e+fd.d/dZ\ee]e)fd.d0d!Z^d1d2Z_ee+e j`feeIjad3d4dZbeeIjad5d6d Zcd7d8Zdd9d:Zed;d<Zfd=d>Zgd?d@ZhdAdZieIjae[e[e[e[dBdCdDZjdee[ee[dEdFdGZkddHee[ee[dEdIdJZldKdLZmde[dMdNdOZndPdQZodRdZpdSdZqdTdUZrdVdWZsdXdYZtdZd[Zud\d]d^d_Zvd`daZweIjxe:dbdcddZyGdedfdfeZzed\dgGdhdidiZ{ed\dgGdjdkdke{Z|ed\dgGdldmdme{Z}ee|e}dfZ~ed\dgGdndodoe{ZGdpdqdqZGdrdsdseIjZGdtdudueIjZGdvdwdweIjZefZedxdydzZd{d|d}d|d~d|dd|dd|dd|dd|dd|dd|dd|dd|d ZddZddZddZddZedd|dd|dd|dd|dd|dd|dd|edd|edd|dd|dd|dd|dZdd|dd|dd|dd|dd|dd|dZejejdZddZddZddZddZddZddZddZddZddZdddddUdhZdddhZddhZddUdddhZddhZddZejejejejejejeeejejejeejejdZdddUdhZddhZddddddddddh ZddZdd̈́ZddτZeD]\ZZeeeqeD]\ZZeeeqddфZeD]4\ZZeekreee)neee+eee*q[[e]d5ddӄZdddՄZed\dgGddׄd׃ZGddلdeKZGddۄdeZGdd݄deKZGdd߄d߃Ze ZGdddZddZddZdS)N) defaultdict)contextmanager) dataclassfield)Enum) lru_cache) AnycastCallableDictListOptionalSetTupleTypeUnion) sym_floatsym_maxsym_minsym_notSymBoolSymFloatSymInt) ShapeGuardSourceTracingContext)FloorDivLShiftModRShift) try_solve) bound_sympySymPyValueRangeAnalysis ValueRangesValueRangeError) format_frameCapturedTraceback)signpost_eventc@s eZdZdS)GuardOnDataDependentSymNodeN__name__ __module__ __qualname__r-r-d/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/torch/fx/experimental/symbolic_shapes.pyr(/sr() StrPrinter) precedencehas_symbolic_sizes_stridescreate_contiguousShapeEnvis_concrete_intSymDispatchMode guard_int guard_float guard_scalar wrap_nodemethod_to_operatorhint_int SYMPY_INTERP free_symbolsis_symbol_binding_fx_nodeis_concrete_boolcCs*ddl}tjt||jjg}dd|DS)NrcSsh|]}t|qSr-)inspectgetfile).0mr-r-r. Isz&uninteresting_files..)Ztorch._inductor.sizevarssysmodulesr*Z _inductorZsizevars)torchmodsr-r-r.uninteresting_filesAs rIc@s eZdZdS)ConstraintViolationErrorNr)r-r-r-r.rJSsrJc@s$eZdZddZddZddZdS)r5cCs tdSN)NotImplementedError)selffunctypesargskwargsr-r-r.__sym_dispatch__fsz SymDispatchMode.__sym_dispatch__cCs,t}t|drt|dn||_|a|S)Ninnerz< has already been used as a mode. Please use a fresh version)SYM_FUNCTION_MODEhasattr RuntimeErrorrS)rMoldr-r-r. __enter__is  zSymDispatchMode.__enter__cCs |jadSrK)rSrT)rMexc_typeexc_valexc_tbr-r-r.__exit__sszSymDispatchMode.__exit__N)r*r+r,rRrXr\r-r-r-r.r5es cCs|jSrK)Z_has_symbolic_sizes_strides)elemr-r-r.r1wscCs:dg}t|ddD]}|||dqtt|SN)reversedappendlist)shapestridesdimr-r-r.r2zscCs6t}|s t|jazg}|||||WS|aXdSrK)rTAssertionErrorrSrR)rNrPrQmoderOr-r-r._handle_sym_dispatchsricCs.t|tjr|jSt|tks*t||SrK) isinstancerGrnode require_hinttypeintrgar-r-r.r;s  cCst|tr|jSdSNT)rjSymTypesrkhas_hintror-r-r.rss  rsrocCs<t|ttfstt|tr dSt|jjtjjj r8dSdS)z Utility to check if underlying object in SymInt is concrete value. Also returns true if integer is passed in. Args: a (SymInt or int): Object to test if it int TF) rjrrnrgrkexprsympycorenumbersIntegerror-r-r.r4s  cCsFt|ttfstt|tr dSt|jjtjjj tjjj frBdSdS)z Utility to check if underlying object in SymBool is concrete value. Also returns true if integer is passed in. Args: a (SymBool or bool): Object to test if it bool TF) rjrboolrgrkrtruZlogicZboolalgZ BooleanTrueZ BooleanFalseror-r-r.r?s  cCstdd|DS)Ncss|]}t|VqdSrK)rsrBsr-r-r. sz#tensor_has_hints..)allsizetr-r-r.tensor_has_hintssr)valreturncCst|ttfr|jjjSt|tjr*|jSt|tt t fr@t St|t j rpt|t|Bt|BSt|ttfrt }|D]}|t|O}q|Std|dt|dS)Nzcannot compute free_symbols of  )rjrrrkrtr=ruExprrnfloatrysetrGTensorr~stridestorage_offsettuplercrgrm)rrr{r-r-r.r=s&      rcCsN|jdkrJd|jkrJt|jdtjrJt|jdjjtjrJ|jdjjSdS)N placeholderr) opmetarjrGrrkrtruSymbol)rkr-r-r.r>scCsdd|jDS)NcSs$i|]}t|r|jdjj|qS)r)r>rrkrt)rBrkr-r-r. s z0find_symbol_binding_fx_nodes..)nodes)graphr-r-r.find_symbol_binding_fx_nodessrcCs(t|tr |jrt|SdSt|S)a+ Returns True only if we can tell that a is True, possibly introducing a guard in the process. If a depends on some unbacked SymInt, we may return False even though there may exist a possible value of the SymInt that would cause the expression to return True. When is it appropriate to use definitely_true? First, if you can use a higher level combinator like parallel_or/parallel_and, prefer using those instead, they are definitely safe (modulo short-circuiting). Second, it can be used if the program would behave equivalently if definitely_true always returned False (parallel_or/parallel_and are examples of this pattern, modulo short-circuiting). Finally, it even be OK if the program wouldn't behave equivalently, so long as the change is semantics preserving. It can be semantics preserving if the program errors in more cases than it did previously (but otherwise behaves identically), or if it changes some quantity in a way that doesn't matter (e.g., strides often fall in this bucket.) Frjrrkrs guard_boolryror-r-r.definitely_trues   rcCs,t|tr"|jrt| SdSt| S)aK Returns True only if we can tell that a is False, possibly introducing a guard in the process. If a depends on some unbacked SymInt, we may return False even though there may exist a possible value of the SymInt that would cause the expression a to be False. See definitely_true for more usage guidance. Frror-r-r.definitely_falses    rcGstdd|DrdSt|S)z Evaluate the logical OR of several arguments, avoiding guarding on unbacked SymInts if another argument is definitely True. css|]}t|VqdSrK)rrBrpr-r-r.r|szparallel_or..T)anyrPr-r-r. parallel_orsrcGstdd|DrdSt|S)z Evaluate the logical FALSE of several arguments, avoiding guarding on unbacked SymInts if another argument is definitely False. css|]}t|VqdSrK)rrr-r-r.r|$szparallel_and..F)rr}rr-r-r. parallel_andsrcCsTt|ttfrt|St|ttfr,t|St|ttfrBt |St d|dS)Nzunrecognized scalar ) rjrryrrrnr6rrr7rgror-r-r.r8(s)r{ compiler_min compiler_max runtime_min runtime_maxcCs|j|d}r8tt|j|t|j||j|<nt|||j|<|j|d}rtt|j|t|j||j|<nt|||j|<dSrK) var_to_rangegetr#builtinsmaxlowerminupperruntime_var_to_range) shape_envr{rrrrrr-r-r._constrain_symbol_range2s  r)rrcCst|ttfrtdt|ts$tt|jjtj s= 0. We use constrain_range to narrow the possible range, declaring that negative symbols are impossible. This permits to definitely answer True to queries like 'nnz >= 0', even if we don't know what the actual (hinted) value of 'nnz' is. In fact, we actually use constrain_range to unsoundly discharge common guards: for an unbacked SymInt produced by nonzero, we will also assume that it is not equal to 0/1 (even though these are perfectly possible values at runtime), because we generally expect graphs that are valid for N=2 to also be valid for N=1. .. warning:: If you use constrain_range in the context of tracing, we do NOT check that the constraint was actually valid at runtime! In fact, we cannot (easily) do so, as we currently unsoundly assume that unbacked SymInt can never be zero/one, even if it may actually take on these values at runtime (we assume that a graph that is valid for N=2 will also be valid for N=1). NrzInvalid value z for range [:]rr) rurrrjrnrkrtrxr$rrgrr)rprrr-r-r.constrain_rangegs2! $rcCst|tsXt|ts"||ksVtqt|jjtjs:td|jj}t||j |jj<nt|jjtjsptd|jj}t|tst||j |jj<nH|jj|jjkstt|jjtjstd| |jj}||j |jj<dS)z Given two SymInts, constrain them so that they must be equal. NB: this will not work with SymInts that represent nontrivial expressions (yet!) rN) rjrrgrkrtrurrrx replacements_find)rpbrnew_varr-r-r.constrain_unifys   rskipcCsVt|tr>t}t|dD] }|j}q|j|jj |j St |t ksRt ||SNr_)rjrr@ currentframerangef_backrk expect_truef_code co_filenamef_linenormryrg)rprframe_r-r-r.rs rcCs0t|tr|jddSt|tks,t||SNr)rjrrkrrmryrgror-r-r.rs rcCs0t|tr|jddSt|tks,t||Sr)rjrrkr6rmrnrgror-r-r.r6s cCs.t|tr|jddSt|ts*t||Sr)rjrrkr7rrgror-r-r.r7s cCst|dr|St|S)N __sym_sqrt__)rUrmathsqrtror-r-r.sym_sqrts rcCsZt|tr|jSt|tkr&||St|tkr<||St|tkrR| |St SdSrK) rjrrrkrmry wrap_boolrnwrap_intr wrap_floatNotImplementedrMnumr-r-r.to_node s       rcCsdd|jjDS)NcSs g|]}|jdkr|jdqS)rr)rrrBnr-r-r. s z'fx_placeholder_vals..rrgmr-r-r.fx_placeholder_valssrcCsdd|jjDS)NcSsg|]}|jdkr|jqS)r)rtargetrr-r-r.rs z*fx_placeholder_targets..rrr-r-r.fx_placeholder_targetssrT ignore_staticcGs|jjt|||dS)Nr)revaluate_guards_for_argsr)rrrPr-r-r. eval_guards"srcGs|jt||SrK)r bind_symbolsr)rrPr-r-r.r%srrtboundcCsd|jjs0|jjs0|jjr0|tjs0t||f|jjs`|jjs`|jjr`|tjs`t||fdS)a8 We assert that the bounds are either Boolean, or not finite, or can be computed in exact prevision via rational arithmetic. The only exception to this is the rare case when the user calls `sqrt(s0)` sqrt is turned into sympy.Pow so we just match for that (it matches more things, but still) N) rZ is_rationalZ is_Boolean is_finitehasruPowrgrrr-r-r._assert_bound_is_rational(s0rc@seZdZdZdZdZdZdS) DimDynamican Controls how to perform symbol allocation for a dimension. It is always sound to default this to DYNAMIC, but the policies DUCK and STATIC can result in better trace-time and compile-time performance, as they reduce the number of allocated symbols and generally make your graph more static. NB: If we notice you've applied a constraint to the dimension, we will force it to DYNAMIC for simplicity. DimDynamic is controlled by a variety of higher level UX features. Currently: - In eager mode, the default policy is DUCK. - The default is changed to STATIC with assume_static_by_default. - An individual dim is marked DYNAMIC if you mark_dynamic_dim. - In export mode, the default policy is STATIC. - An individual dim is marked DYNAMIC if you mention it as dynamic_dim in the constraints kwarg. rr_rN)r*r+r,__doc__DYNAMICDUCKSTATICr-r-r-r.r2srfrozenc@seZdZUeed<dS) Constraint warn_onlyN)r*r+r,ry__annotations__r-r-r-r.r^s rc@s(eZdZUdZeed<edddZdS)StrictMinMaxConstrainta- For clients: the size at this dimension must be within 'vr' (which specifies a lower and upper bound, inclusive-inclusive) AND it must be non-negative and should not be 0 or 1 (but see NB below). For backends: there must not be any guards on this dimension which are not implied by the given lower and upper bound. Regardless of the lower bound, the backend can assume the size is non-negative and that it is not 0 or 1. An unbounded StrictMinMaxConstraint can be thought of as a strict version of "RelaxedUnspecConstraint". NB: Export will often unsoundly assume that a graph works for 0/1, even though at trace time we assumed size is not 0 or 1. The idea is that if we produce a graph that works for a range of values, it will be OK for N=0/1 too. vrsourcecCs |jjd|d|jjS)N <= )rrnamerrMrr-r-r.renderxszStrictMinMaxConstraint.renderN)r*r+r,rr#rrrr-r-r-r.rbs rc@seZdZdZedddZdS)RelaxedUnspecConstrainta For clients: no explicit constraint; constraint is whatever is implicitly inferred by guards from tracing. For backends: there must exist at least TWO possible values for the size at this dimension which satisfy the guards for this dimension. In other words, this constraint helps us distinguish between "we don't care if this dimension specializes or not" versus "this dimension must be unspecialized." However, this constraint doesn't say very much about what specialization is permitted; for example, if we guard on a size being even, this would still be acceptable under an unspec constraint. This makes RelaxedUnspecConstraint useful for eager mode, where your backend compiler may add constraints to otherwise dynamic dimensions; we can't assert that there are NO guards as this is brittle because compilers should be able to add extra constraints. If you want to assert that there are no guards, use StrictMinMaxConstraint with an unbounded ValueRanges. rcCsd|dS)NzRelaxedUnspecConstraint()rrr-r-r.rszRelaxedUnspecConstraint.renderN)r*r+r,rrrr-r-r-r.r|src@sNeZdZUdZeeeefed<ddZddZ ddZ d d Z d d Z d S)EqualityConstraintz Given pairs of sources corresponding to pairs of dynamic dimensions that are specified equal, represent them in a union-find data structure so that we can efficiently check whether two such sources are transitively equal. source_pairscCs:t|di|jD] \}}|||||qdS)N_parents)object __setattr__r_unionrrMsource1source2r-r-r. __post_init__sz EqualityConstraint.__post_init__cCs"||jkr||j|S|SdSrK)rrrr-r-r.rs zEqualityConstraint._findcCs||kr||j|<dSrK)r)rMZroot1root2r-r-r.rszEqualityConstraint._unioncCs"ddd|jD}d|dS)N, css(|] \}}|d|VqdS) == Nr)rBrrr-r-r.r|sz,EqualityConstraint.render..{})joinr)rMbufr-r-r.rs zEqualityConstraint.rendercCs||||kSrKrrr-r-r.is_equalszEqualityConstraint.is_equalN) r*r+r,rr rrrrrrrrr-r-r-r.rs rc@seZdZdZdyeeeefdddZe ddZ dd Z e d d Z d d Z ddZddZddZddZddZddZddZddZddZd d!Zd"d#Zd$d%Zdd&d'd(Zdd&d)d*Zdd&d+d,Zdd&d-d.Zdd&d/d0Zdd&d1d2Zdd&d3d4Z dd&d5d6Z!dd&d7d8Z"dd&d9d:Z#dd&d;d<Z$dd&d=d>Z%dd&d?d@Z&dd&dAdBZ'dd&dCdDZ(dd&dEdFZ)dd&dGdHZ*dd&dIdJZ+dd&dKdLZ,dd&dMdNZ-dd&dOdPZ.dd&dQdRZ/dd&dSdTZ0dd&dUdVZ1dd&dWdXZ2dd&dYdZZ3dd&d[d\Z4dd&d]d^Z5dd&d_d`Z6dd&dadbZ7dd&dcddZ8dd&dedfZ9dgdhZ:didjZ;dkdlZdqdrZ?dsdtZ@dudvZAdwdxZBdS)zSymNodez This is a type erased SymInt/SymFloat which we use to do actual operations. End users don't touch this. Magic methods are NOT defined on this object. NhintcCs`||_||_||_|dkr:|j|j|_d|_|n d|_||_||_ t rV|nd|_ dSrK) _exprrpytypertxreplace var_to_val _hint_expr_hint _update_hintconstant_translation_validation_enabledfx_node)rMrtrrrrrr-r-r.__init__s zSymNode.__init__cCs|j|jSrK)rreplacerrMr-r-r.rtsz SymNode.exprcCsH|jj|jjkrD|j|j}|jr2||_dS|||_d|_dSrK)rr=rrkeysrrr)rMZnew_hintr-r-r.rs zSymNode._update_hintcCs|jdkr||jSrK)rrr r-r-r.rs z SymNode.hintcCs |jdk SrK)rr r-r-r.rsszSymNode.has_hintcCsB|jdkr8||jdkr0|j|j|jq>|jSn|jSdSrK)rrr_make_data_dependent_errorrrtr r-r-r.rls   zSymNode.require_hintcCs|jjr dSt|jSdSrK)rtr=rnr r-r-r. maybe_as_int szSymNode.maybe_as_intcCs |jtkSrK)rrnr r-r-r.is_intszSymNode.is_intcCs |jtkSrK)rrr r-r-r.is_floatszSymNode.is_floatcCs |jtkSrK)rryr r-r-r.is_boolszSymNode.is_boolcCs,t|tksttt||jt|||dSN)rr)rmrnrgrrurxrrr-r-r.rszSymNode.wrap_intcCs,t|tksttt||jt|||dSr')rmrrgrruFloatrrr-r-r.rszSymNode.wrap_floatcCs2t|tkstt|rtjntj|jt|||dSr')rmryrgrrutruefalserrr-r-r.r#szSymNode.wrap_boolcCs|SrKr-r r-r-r.clone'sz SymNode.clonecCs|jSrKrtr r-r-r.str*sz SymNode.strcCs|SrKr-r r-r-r.__str__-szSymNode.__str__cCs|SrKr.r r-r-r.__repr__0szSymNode.__repr__rcCs ||SrK)_addrMotherr-r-r.add5sz SymNode.addcCs ||SrK)_subr2r-r-r.sub8sz SymNode.subcCs ||SrK)_mulr2r-r-r.mul;sz SymNode.mulcCs ||SrK)_modr2r-r-r.mod>sz SymNode.modcCs ||SrK)Z_powr2r-r-r.powAsz SymNode.powcCs ||SrK)Z_and_r2r-r-r.and_Dsz SymNode.and_cCs ||SrK)Z_or_r2r-r-r.or_Gsz SymNode.or_cCs ||SrK)Z_truedivr2r-r-r.truedivJszSymNode.truedivcCs ||SrK) _floordivr2r-r-r.floordivMszSymNode.floordivcCs ||SrK)Z_lshiftr2r-r-r.lshiftPszSymNode.lshiftcCs ||SrK)Z_rshiftr2r-r-r.rshiftSszSymNode.rshiftcCs|SrK)Z_sym_notr r-r-r.rVszSymNode.sym_notcCs ||SrK)_eqr2r-r-r.eqYsz SymNode.eqcCs ||SrK)Z_ner2r-r-r.ne\sz SymNode.necCs ||SrK)Z_gtr2r-r-r.gt_sz SymNode.gtcCs ||SrK)Z_ltr2r-r-r.ltbsz SymNode.ltcCs ||SrK)Z_ler2r-r-r.leesz SymNode.lecCs ||SrK)Z_ger2r-r-r.gehsz SymNode.gecCs|SrK)Z_floorr r-r-r.floorksz SymNode.floorcCs|SrK)Z _sym_floatr r-r-r.rnszSymNode.sym_floatcCs|SrK)Z_sym_intr r-r-r.sym_intqszSymNode.sym_intcCs|SrK)_ceilr r-r-r.ceiltsz SymNode.ceilcCs|SrK)Z_negr r-r-r.negwsz SymNode.negcCs ||SrK)Z_sym_minr2r-r-r.rzszSymNode.sym_mincCs ||SrK)Z_sym_maxr2r-r-r.r}szSymNode.sym_maxcCs|SrK)Z _sym_sqrtr r-r-r.rszSymNode.sym_sqrtcCs |||SrK)Z_is_contiguousrMsizesrer-r-r. is_contiguousszSymNode.is_contiguouscCs |||SrK)Z_is_channels_last_contiguous_2drOr-r-r.is_channels_last_contiguous_2dsz&SymNode.is_channels_last_contiguous_2dcCs |||SrK)Z_is_channels_last_contiguous_3drOr-r-r.is_channels_last_contiguous_3dsz&SymNode.is_channels_last_contiguous_3dcCs |||SrK)Z_is_channels_last_strides_2drOr-r-r.is_channels_last_strides_2dsz#SymNode.is_channels_last_strides_2dcCs |||SrK)Z_is_channels_last_strides_3drOr-r-r.is_channels_last_strides_3dsz#SymNode.is_channels_last_strides_3dcCs |||SrK)Z'_is_non_overlapping_and_dense_indicatorrOr-r-r.&is_non_overlapping_and_dense_indicatorsz.SymNode.is_non_overlapping_and_dense_indicatorcCs ||SrK)r=r2r-r-r.sym_orszSymNode.sym_orcCs ||SrK)r<r2r-r-r.sym_andszSymNode.sym_andcCs|||t|dSr)rVrDrrOr-r-r.is_non_overlapping_and_densesz$SymNode.is_non_overlapping_and_densecCs |ddSr)r6r r-r-r.int_sz SymNode.int_cCsJ|jj|j|j|jd}z t|WStk rDtd|YnXdS)NrzFailed to convert to int: %s) r evaluate_exprrtrrrn ExceptionlogwarningrMfilelinerr-r-r.r6s   zSymNode.guard_intcCsJ|jj|j|j|jd}z t|WStk rDtd|YnXdS)Nr[zFailed to convert to float: %s) rr\rtrrrr]r^r_r`r-r-r.r7s   zSymNode.guard_floatcCsJ|jj|j|j|jd}z t|WStk rDtd|YnXdS)Nr[zFailed to convert to bool: %s) rr\rtrrryr]r^r_r`r-r-r.rs   zSymNode.guard_boolcCs4|r|||S|jj|j|d||jdS)Nrr[)rsrrdefer_runtime_assertrtr)rMrarbr-r-r.rs zSymNode.expect_truecCs |ddSr)rr r-r-r.bool_sz SymNode.bool_)NN)Cr*r+r,rr rrnrrpropertyrtrrrsrlr#r$r%r&rrrr+r-r/r0r4r6r8r:r;r<r=r>r@rArBrrDrErFrGrHrIrJrrKrMrNrrrrQrRrSrTrUrVrWrXrYrZr6r7rrrdr-r-r-r.rsz%        rc@seZdZeddZdS)rcCs:|jrtdS|jr.|dkr.t|dn||SdS)Nr_rz% cannot be raised to a negative power)is_zerorurxZeroDivisionError)clsbaseexpr-r-r.evals  zPow.evalNr*r+r, classmethodrkr-r-r-r.rsrc@seZdZeddZdS)TrueDivcCs|jrtdn||SdS)Nzdivision by zero)rfrg)rhridivisorr-r-r.rks z TrueDiv.evalNrlr-r-r-r.rnsrnc@seZdZdZeddZdS)!IsNonOverlappingAndDenseIndicatorTcGslt|ddkstt|d}tdd|Drh|d|}||d}tdd|Ddd|DSdS)Nrrcss|]}t|tjVqdSrK)rjrurxrr-r-r.r|sz9IsNonOverlappingAndDenseIndicator.eval..cSsg|] }t|qSr-rnrr-r-r.rsz:IsNonOverlappingAndDenseIndicator.eval..cSsg|] }t|qSr-rqrr-r-r.rs)lenrgr}!eval_is_non_overlapping_and_dense)rhrPrfZ size_argsZ stride_argsr-r-r.rks     z&IsNonOverlappingAndDenseIndicator.evalN)r*r+r, is_integerrmrkr-r-r-r.rpsrpcCsFt|dr>z t|WStk r:td||YSXn|SdS)Nexpandz"RecursionError in sympy.expand(%s))rUrurvRecursionErrorr^r_)rr-r-r. safe_expands    rxcCs||SrKr-rprr-r-r.rzcCs||SrKr-ryr-r-r.rzr{cCs||SrKr-ryr-r-r.rzr{cCs t||SrK)rryr-r-r.rzr{cCs t||SrK)rryr-r-r.rzr{cCs t||SrK)ruAndryr-r-r.rzr{cCs t||SrK)ruOrryr-r-r.rzr{cCs t||SrK)rnryr-r-r.rzr{cCs t||SrK)rryr-r-r.rzr{cCs t||SrK)rryr-r-r.rzr{cCs t||SrK)rryr-r-r.rzr{) r4r6r8r:r;andorr>r@rArBcCs tddS)Nzshouldn't be hit)rgr-r-r-r.errorsrcCst|tjr^|j}t|dkr^t|dtjr^|djr^t|d}|d|kr^||dSt|tjrx|t|kst|tjrt|S||SNrrr_)rjruZMulrPrrr(rtrx)rpfnZaaZcoefr-r-r.floor_ceil_helper!s &  & rcCs t|tjSrK)rrurJror-r-r. floor_impl,srcCs t|tjSrK)rruceilingror-r-r. ceil_impl/srcCs|SrKr-ror-r-r.rz5r{cCs t||SrK)ruEqryr-r-r.rz6r{cCs t||SrK)ruNeryr-r-r.rz7r{cCs t||SrK)ruGtryr-r-r.rz8r{cCs t||SrK)ruLtryr-r-r.rz9r{cCs t||SrK)ruLeryr-r-r.rz:r{cCs t||SrK)ruGeryr-r-r.rz;r{cCs|SrKr-ror-r-r.rz=r{cCs| SrKr-ror-r-r.rz?r{cCs t||SrK)ruMinryr-r-r.rz@r{cCs t||SrK)ruMaxryr-r-r.rzAr{cCs t|SrK)rurror-r-r.rzBr{)rrDrErFrGrHrIrJrrMrNrrrcCs t||SrK)sympy_is_contiguousrPrer-r-r.rzHr{cCs t||SrK)$sympy_is_channels_last_contiguous_2drr-r-r.rzIr{cCs t||SrK)$sympy_is_channels_last_contiguous_3drr-r-r.rzJr{cCs t||SrK)!sympy_is_channels_last_strides_2drr-r-r.rzKr{cCs t||SrK)!sympy_is_channels_last_strides_3drr-r-r.rzLr{cCs t||SrK)rprr-r-r.rzMr{)rQrRrSrTrUrV)rrcCst|}t||krtjStj}td}|D]:}|t||tdt|||BM}|||9}q.t|D]}|t||tdO}qr|S)Nr_r)rrrur*r)rxrr)rPre dim_orderrfrQzdr-r-r.sympy_is_contiguous_genericUs  * rcCs$t|}t||tt|dddSr^)rrrrcr)rPrerfr-r-r.rfsrcCst||ddddgSNr_rrrrr-r-r.rmsrcCst||dddddgSNr_rrrrrr-r-r.rpsrcCst|}|t|krtjStd}tj}|t|ddM}|D]X}|t||d|||k@M}|dkr|t||dM}||t||d}qB|S)Nrr_)rrrur*rxr)rr)rPrerrfrCrrr-r-r.&sympy_is_channels_last_strides_genericss    rcCst||ddddgSrrrr-r-r.rsrcCst||dddddgSrrrr-r-r.rsrcCsttt||SrK)rnr"_eval_is_non_overlapping_and_denserr-r-r.rssrscCsvt|}|dkr(|ddkp&|ddkStt||tdd}d}|D](\}}|dkrZqH||krhdS||9}qHdS)Nr_rrkeyFT)rrsortedzipoperator itemgetter)rPrerfZlengths_and_stridesZexpected_stridelengthrr-r-r.rs  rrrMrJrNrr~rrrcCsT|tkr|d}n|}|tkr2ttjjj|}n|tkrFtt|}n tt |}|S)Nr) 2magic_methods_on_operator_with_trailing_underscoremagic_methods_on_submodulegetattrrGfxZ experimentalZsymbolic_shapesmagic_methods_on_mathrr)method method_attrrr-r-r.r:s   )rrrrrrrrrrrnrprJrr>r;rDrErFrGrHrIrYcCs\t|tr|jdk r|jS|r*t|S|r:t|S|rJt|St d|dS)Nzunrecognized return type ) rjrrr$rr%rr&rrgxr-r-r.r9scsrtdtkr d}n}fdd}fdd}tkr\ttd||nttd||dS)Nrurc s@t}d}|jdk r.|jdk r.||j|j}t}|r\|dk r\t||t|t|Str~t|t|t|t|fiSt|t st z|j |j }Wn*t k rt d|j |j YnXt|}tkrt}n2tkrt}n$|jtks|jtkr t}n|j}|j||j|jf\}}t ||j|||dS)Nfailed to eval %s(%s, %s)r[)r:r alternate_impl_if_hinted_methodsrrr9rTrirjrrgrtr]r^r_rxalways_float_magic_methodsralways_bool_magic_methodsryrrcreate_fx_call_functionr) rMr3rout_hintZalternate_imploutrrrrNrr-r.binary_magic_impls2   z+_make_node_magic..binary_magic_implcst}tr$t|t|t|fiS|j}dks:dkrF|j|}z |}Wn$tk rvt d|YnXd}|j dk r||j }t |}t krt}ntkrt}n|j}|j||jf\}}t||j|||dS)NrJrzfailed to eval %s(%s)r[)r:rTrrir9rtr_simplify_floor_divr]r^r_rrxalways_int_magic_methodsrnrrrrrr)rMrrtrrrrrrr-r.unary_magic_impl/s,    z*_make_node_magic..unary_magic_impl)rrunary_magic_methodssetattrr)rrNrrrr-rr._make_node_magics  +rcsTfdd}ttd|fdd}ttjtsPttjt|dS)Nc sttjt}tr>t|t|dd|Ddd|DfiSdd|D}dd|D}z||}Wn&tk rt d||YnXg}d}|D]} | j dkrq| | j qg} |D]} | j dkrq| | j q||| } drt } nt} t||j| |S)NcSsg|] }t|qSr-)r9rzr-r-r.r\szH_make_node_sizes_strides..sizes_strides_impl..cSsg|] }|jqSr-r,rzr-r-r.r`scSsg|] }|jqSr-r,rzr-r-r.rasrZ _indicator)rrErFr*rTrrir]r^r_rrbendswithrnryrr) rMrPrerZ size_exprsZ stride_exprsrZ size_hintsrr{Z stride_hintsrrr-r.sizes_strides_implUsB    z4_make_node_sizes_strides..sizes_strides_implrcst||D]Dttr ttjfdd|Dfdd|DSq dkrdt||Stdd|Ddd|DSdS)Ncsg|]}tj|qSr-rrkrBrror-r.rszH_make_node_sizes_strides..sizes_strides_user..csg|]}tj|qSr-rrror-r.rsrVcSsg|]}t|qSr-rusympifyrr-r-r.rscSsg|]}t|qSr-rrr-r-r.rs) itertoolschainrjrr9rrkrsryrrror.sizes_strides_users      z4_make_node_sizes_strides..sizes_strides_user)rrrUrErFr*)rrNrrr-rr._make_node_sizes_stridesRs +rcs|tkr|dn|fdd}fdd}fdd}|tkrZt|d|d|n0t|d|d||tkrt|d |d|dS) Nrcstt|jSrK)r9rrkr rr-r.rsz*_make_user_magic..unary_magic_implcs,t|j|}|tkrtStt|j|SrKrrkrr9rrMr3Z other_noderr-r.rs z+_make_user_magic..binary_magic_implcs,t|j|}|tkrtStt||jSrKrrrr-r.rbinary_magic_impls z,_make_user_magic..rbinary_magic_impl____r)rrrreflectable_magic_methods)rZ user_typerrrr-rr._make_user_magics    rcCsddlm}|S)Nrtranslation_validation_enabled)torch.fx.experimental.validatorrrr-r-r.rs rcs<t||dt|fdd}j|_j|_|S)z Wrapper around lru_cache that clears when new info about shapes has been updated. Use lru_cache if the output is always the same, regardless of the constraints we know now (i.e. evaluate_expr) Use _lru_cache otherwise. Ncs,|kr||f||SrK)_get_key cache_clear)rMrPrQZfn_cacheZ prior_keyr-r.wrappers z_lru_cache..wrapper)r functoolswrapsr cache_info)rmaxsizerr-rr. _lru_caches rc@s<eZdZUejed<eddZeed<eddZ eed<dS) RuntimeAssertrtF)reprmsgstackN) r*r+r,rurrrrr-rr-r-r-r.rs  rcs*eZdZfddZedddZZS)ShapeGuardPrintercs t||_||_||_dSrK)superrsymbol_to_source source_refvar_to_sources)rMrrr __class__r-r.rs zShapeGuardPrinter.__init__rcstt|tjsttt|fdd}j|s`t|dddj|Dd|d j|dS) NcstddjDS)NcSs i|]\}}|dd|DqS)cSsg|] }|qSr-rrzr-r-r.rsz]ShapeGuardPrinter._print_Symbol..repr_symbol_to_source...r-)rBsymbolsourcesr-r-r.rszRShapeGuardPrinter._print_Symbol..repr_symbol_to_source..)rritemsr-r r-r.repr_symbol_to_sourcesz>ShapeGuardPrinter._print_Symbol..repr_symbol_to_sourcez (could be from cSsg|] }|qSr-rrzr-r-r.r sz3ShapeGuardPrinter._print_Symbol..z ) not in zu. If this assert is failing, it could be due to the issue described in https://github.com/pytorch/pytorch/pull/90665r) rjrurrgr-rmrrrr)rMrtrr-r r. _print_Symbols  &zShapeGuardPrinter._print_Symbol)r*r+r,rr-r __classcell__r-r-rr.rs rcseZdZfddZZS)LoggingShapeGuardPrintercst|dd|dS)NcSs|SrKrrr-r-r.rzr{z3LoggingShapeGuardPrinter.__init__..)rr)rMrrr-r.rsz!LoggingShapeGuardPrinter.__init__)r*r+r,rrr-r-rr.rsrcsDeZdZdZfddZedddZedddZd d ZZ S) DynamicDimConstraintPrinterz Printer for dynamic dim constraints. - Instead of t.size()[d] it prints dynamic_dim(t, d) - Instead of Eq(_, _), Mod(_, _), etc. it prints _ == _, _ % _, etc. We use this to suggest code for specifying dynamic dim constraints. cst||_dSrK)rrr)rMrrr-r.rs z$DynamicDimConstraintPrinter.__init__rcCsd|jd|jdS)Nz dynamic_dim(r r)riridxrr-r-r. print_source!sz(DynamicDimConstraintPrinter.print_sourcecCs0t|tjsttt|||j|dSNr)rjrurrgr-rmrrrMrtr-r-r.r$sz)DynamicDimConstraintPrinter._print_Symbolc Cs,d||jt||j||jt|S)Nz{} {} {})formatZ parenthesizelhsr0Zrel_oprhsrr-r-r._print_Relational)s z-DynamicDimConstraintPrinter._print_Relational) r*r+r,rrr-rrrrr-r-rr.rs  rc@seZdZdZddZddZedddZd d Zd d Z d dZ ddZ ddZ dddZ ddZddZejdddZdS)DimConstraintsz Custom solver for a system of constraints on symbolic dimensions. Solutions are "static" values or simplified "dynamic" constraints. cCs`tt|_t|_i|_||_tt|_t|_g|_t|_ t|_ t ||_ g|_ ||_dSrK)rr_univariate_inequalities_symbols_with_equalities_substitutions _var_to_val _congruences_multivariate_inequalities_symbolic_equivalences_static_results_dynamic_resultsr_dcp_inconsistencies_marked_dynamic)rMrrZmarked_dynamicr-r-r.r7s   zDimConstraints.__init__csLfdd}fdd}|tr2|t|}|trH|t|}|S)aA Eliminate expressions of the form b // d and b % d while adding congruences of the form b % d == k. This leaves rational operators (in particular of the form b / d) that our inequality solver can handle. We solve the added congruences separately (using our congruence solver, see below). csb|\}}||}}|j|j}|||}|dkr^j||Srrewrite_with_congruencessubsrrr4rPriroZ mod_reduced congruencer{rMr-r. mod_handlergs z.mod_handlercsj|\}}||}}|j|j}|||}|dkr^j||||Srrr r r-r.floor_div_handlers zBDimConstraints.rewrite_with_congruences..floor_div_handler)rrrr)rMr{rtr rr-r r.ras     z'DimConstraints.rewrite_with_congruencesrcCs|tjkrdS|}||j}|tjkr:|j|d|j}|sRtd|t |dkrl|j |n|t t |}|||}|tjkrdS||j}|tjkr|j|d|dt|tjr|j ||j| |dS)NTz is inconsistent!z2Did not expect constraint with no free variables: r_z, obtained by rewriting z# with congruences, is inconsistent!F)rur)r rr*rrbr=rgrrrr4nextiterrrjrrr)rMrt orig_exprZ orig_reducedr=r{Zreducedr-r-r.r4s.           zDimConstraints.addcCs6|jr|j||fn|j|d|dS)Nr )r=rrbrr4r)rMrrtr-r-r. add_equalityszDimConstraints.add_equalitycs&i}|jD]\}}g}t}|D]}|j\}}tjddd} tj||| |gd\} } || krtjj | | \} } t | tj rt | tj r| | } | | | fq&| |q&|rtjjj|\} } || | h||<|| tjddd| i||fdd|Dq|||<q|S)NtmpTinteger)symbolsc3s|]}t|s|VqdSrK)ruchecksol)rBr Z substitutionr-r.r|s z4DimConstraints.reduce_congruences..)rrrrPrurZ solve_linearZpolysZ polytoolsdivrjrxrbr4ZntheoryZmodularZsolve_congruenceupdate)rMreduced_congruencesr{ congruencesZremainder_modulus_pairsZcongruences_to_checkr rirorrsolutionmodulus remainderr-rr.reduce_congruencess0    z!DimConstraints.reduce_congruencescCs.|jr*d|j}|jtd|dS)N z*The following inconsistencies were found: )rr clearr)rMrr-r-r.raise_inconsistenciess  z$DimConstraints.raise_inconsistenciescCs>|j|}|j|jj|dd|||j|<dS)Nrr )rrr4rrrr)rMr{rr-r-r._force_specializations &z$DimConstraints._force_specializationcsjD]6}|ttD]$}|j\}}|jD]}|q*qqj}t_|D]}| j qP fddj D_ fddj D_dS)Ncs i|]\}}|jkr||qSr-r)rBr{exprsr r-r.r s z=DimConstraints.specialize_divisor_symbols..cs i|]\}}|jkr||qSr-r%)rBr{rr r-r.rs )ratomsrrrPr=r$rr4r rr#rrr)rMrtatomrror{multivariate_inequalitiesr-r r.specialize_divisor_symbolss      z)DimConstraints.specialize_divisor_symbolsTc s||jr|j}|j|}tjj||}t|tj rXt dd|j D|}t|tj sxt d|d||j \}}||kst d|d||j|jj|dd|||j|<|j}t|_|D]} || ||j|q|q||} | D]v\}} | D]f} ||jksTt| ||j|is,|rt|||j|dn|j|jt | dq,q |jD]\}}zZtjj||}t|tj r|j D]} |j|j| qn|j|j|WnPtk rT}z0t d ||D]} |j|j| q(W5d}~XYnXq|j!}g|_!|D]l\}} |rt| tj"s| j#D]2}|||j$|fd d |jD|_q|%|| |jqj|j!D]0\}} |j|j&|d|j| qdS) Ncss|]}t|tjr|VqdSrK)rjrur)rBargr-r-r.r|s z'DimConstraints.solve..z$Expected an equality constraint for z, got zExpected a constraint on z instead of on rr z!Failed to reduce inequalities: %scsh|]}|kr|qSr-r-rBrsexprr-r.rDTsz'DimConstraints.solve..)'r#rpoprruZsolversZ inequalitiesZreduce_inequalitiesrjr|rrPrrgrr4rrrrrrr r*r rrr$rdoprintrLr^r_rrr=rrr)rMZdisable_congruencesZdisable_equivalencesr{r&rrrr)rtrrr r+eZsymbolic_equivalencesrr-r-r.solves`     &  $ $  .    zDimConstraints.solvecsdfddjDS)Nr!cs<g|]4\}}|jkrdjj|dd|dqS) rz3, which was marked dynamic, must be specialized to .)rrrr)rBr{rr r-r.r]s z9DimConstraints.forced_specializations..)r rrr r-r r.forced_specializations\sz%DimConstraints.forced_specializationscCs~g}t}|jD]0}tdd|}||kr6||q||q|D],}d}|D]}||krRd}qR|sF||qF||_dS)Nz2 <= dynamic_dim(.+)z dynamic_dim\1FT)rrrer6rbr4)rMZcandidates_for_removalZdynamic_resultsdcZdc_foundZother_dcr-r-r. remove_redundant_dynamic_resultsfs    z/DimConstraints.remove_redundant_dynamic_results)original_signaturec sddfdd}|jtjjd}i}t|jD]\}}||f||<q6fdd}dd }|jr||j|} d 7d t|d 7|| |d dd7|j r||j |} d7d7dt|d 7d|d7|| |dddd|d7S)NcSs8td|}|dkrdS|d}tdd|}||fS)Nz L\['(.+?)'\]z\1)r6searchrvr6)r7matchr+r-r-r.extract_and_rewrite_locals   zBDimConstraints.prettify_results..extract_and_rewrite_localc stt}|D]<}|}|dkr"q |\}}||kr ||||q q q g}t|D]"\}}|\} }||t|fqZ|SrK)rrcrbrr) results args_indexgroupsr7localr+Z sorted_groupsrZdcsr)r=r-r.groupsz.DimConstraints.prettify_results..group)return_annotationcs^d}|D]P\}}|rd7nd}d|d|d7|D]}d|||7qresult)rr-r. print_resultss  z6DimConstraints.prettify_results..print_resultsrz zF The following dimensions have been specialized and CANNOT be dynamic.z ``` def specializationsrcSs d|S)Nzassert r-rGr-r-r.rzr{z1DimConstraints.prettify_results..z ``` z) The following dimensions CAN be dynamic.zL Please use the following code to specify the constraints they must satisfy:z ``` def specify_constraintsr!zreturn [rcSs |dS)N,r-rIr-r-r.rzr{z] ``` ) rr@ Signatureempty enumerate parametersr!rr-r) rMr:rB signaturer?ir+rHrEZgrouped_static_resultsZgrouped_dynamic_resultsr-)rr=r.prettify_results|s@    zDimConstraints.prettify_resultsN)TT)r*r+r,rrrryr4rr r#r$r*r2r5r9r@rKrQr-r-r-r.r1s*;&) G rc @seZdZdddddddddZddZeeejd d d Z eje dd d dZ ddddZ ddddZ ddddZeeeeejjefdddZeje eejjd ddZeejjddddZddZed d!Zd"d#Zejeeeeee ej!d$d%d&Z"ee#eeee ee ej!d'd(d)Z$ddd*ejeeeeeeed+d,d-Z%dd.d/ee#eed0d1d2Z&d3d4Z'd/d5d6d7Z(d8d9Z)d:d;Z*dd?d@Z-ej,ddfe#eeeeed/dAdBdCZ.dDdEZ/dFdGfdddddHee0e1eeeefee2eeefe e3dIdJdKZ4ddLdMdNZ5dOdPZ6dQdRZ7ddSdTZ8dUdVZ9e:dddWd/eedXdYdZd[Z;e:d/d/d\d]d^Ze?dcd/dddedfZ@e?dcd/dddgdhZAdidjZBdkd/ddldmdnZCe:dkd/dodpdqZDe?dce1dreddsdtduZEeFddvdwZGeFddxdyZHe:dzd{ZId|d}ZJe3d~ddZKe?dcdd/dddZLddZMdd/dddZNeOddddZPdS)r3TFN)allow_scalar_outputsallow_dynamic_output_shape_opsassume_static_by_defaultspecialize_zero_one duck_shape co_fieldscCs ||_||_g|_i|_i|_i|_i|_i|_i|_i|_ t |_ i|_ |rft dt dd|_ t|_t|_tt|_d|_||_||_||_t|_|jdd|_d|_t|_ |r|ni|_!i|_"i|_#t$rddl%m&}||_'t(j)*|_+|j+,|j+-ddS)Nrr_rr_Z create_envF)TranslationValidator).rRrSguardsrrrr var_to_stack var_to_guardsrr divisible val_to_varrurxrcountunbacked_symfloat_counterunbacked_symint_counter collectionsrrcdeferred_runtime_assertsnum_deferred_runtime_assertsrTrUrVr^infordim_constraintsCountercounterrW fx_node_cachesource_to_symbolrrrY validatorrGrZGraphrZinserting_beforeoutput)rMrRrSrTrUrVrWrYr-r-r.rsD       zShapeEnv.__init__cCs d|_dSrqrr r-r-r.freezeMszShapeEnv.freeze)rrcCs:ts dS|}||jkr0tj|dd|j|<|j|S)NTr)rrrjrur)rMrsrcnamer-r-r._create_symbol_for_sourcePs  z"ShapeEnv._create_symbol_for_source)rrmrcCstr|j||dSrK)rrkZadd_var)rMrrmr-r-r. _add_z3varXszShapeEnv._add_z3varrcCstr|j|dSrK)rrkZadd_target_exprrr-r-r._add_target_expr\szShapeEnv._add_target_exprcCstr|j|dSrK)rrkZ add_assertionrr-r-r._add_assertion`szShapeEnv._add_assertioncCstr|jdSrK)rrkvalidater r-r-r._check_translation_validatedsz$ShapeEnv._check_translation_validate)rrPrcCs||f}d}tr||jkrddlm}tdd|DrXtdd|DsPtd|fSd}tdd|Dstd |jd ||||j}|j |||j|<|j |d|fS) NFr)z3opcss|]}|dkVqdSrKr-rr-r-r.r|vsz3ShapeEnv.create_fx_call_function..css|]}t|tjj VqdSrK)rjrGrNoderr-r-r.r|ysTcss|]}|dk VqdSrKr-rr-r-r.r|szmissing arg in FX graph (z): ) rrirrurr}rgr*rkrZ call_functionr)rMrrPnode_keyfreshruZ lifted_opr-r-r.rhs ( z ShapeEnv.create_fx_call_functionc Csrts dS|jj|ff}||jkrh|||tddtdd|j}|j|}||jd<||j|<|j|S)Nz [^a-zA-Z0-9]rz[()]rr) rrrrirpr6r6rr)rMrrmrwZ mangled_namerkr-r-r.create_fx_placeholder_and_z3vars     z(ShapeEnv.create_fx_placeholder_and_z3var)rkrcCstr|dk r|j|dSrK)rrZ erase_node)rMrkr-r-r.remove_fx_nodeszShapeEnv.remove_fx_nodecCs ttddS)Nsuppress_guardsF)rTLSr r-r-r._suppress_guards_tlsszShapeEnv._suppress_guards_tlsccsdt_z dVW5dt_XdS)NTF)r|r{r r-r-r.r{s zShapeEnv.suppress_guardscCst|jt|j|jfS)z Defines the current "state" of the guards we've accumulated in this ShapeEnv. Determines when we need to invalidate our cache )rrrr]rdr r-r-r.rszShapeEnv._get_key)exr dynamic_dimsconstraint_dimsrcCs|t||||SrK)!_produce_dyn_sizes_from_int_tuplerr~)rMr~rrrr-r-r._produce_dyn_sizesszShapeEnv._produce_dyn_sizes) tensor_sizerrrrc Csrtdd|Ds td|ddlm}m}g}t|D]0\}} ||| |||j|||||q<|S)Ncss|]}t|tVqdSrK)rjrn)rBrr-r-r.r|sz=ShapeEnv._produce_dyn_sizes_from_int_tuple..z0Expect size to be a plain tuple of ints but got rTensorPropertySourceTensorProperty) r}rgtorch._dynamo.sourcerrrMrb create_symbolSIZE) rMrrrrrrr~rPrr-r-r.rs  z*ShapeEnv._produce_dyn_sizes_from_int_tuple)rr)r~rrrc s$tdfdd tfdd|Dtfdd|D|}|}|dkrldg|}|dkrg}t|D]4}t||rtj }nj rtj }ntj }| |qtj g|}tdd|Drtj ntj } t||kstt||kstd d lmm||dgttD]"\}} | d kr8t| |<q8td dDrhfd dttD} tfddttD} | D]V\} }|dkr|| kr| ||<||| ||<qtddDr\tfddttD\} }j| j|| dd|<q\tddDstfddttD}g}tD]<\}}|dk st| j||j|dqjj|j| dd|jd}|||fS)z Returns a list of symbolic sizes and strides for the given tensor. We try our best to express stride in terms of the sizes, so as to not introduce new symbolic variables. rcs@t|ttjfstt|tr<|jjk s2td|jS|S)NzFexpect the symbol is created from an shape env other than current one.)rjrnrGrrgrkrrl)Z maybe_symr r-r."maybe_specialize_sym_int_with_hints  zaShapeEnv.create_symbolic_sizes_strides_storage_offset..maybe_specialize_sym_int_with_hintc3s|]}|VqdSrKr-)rBszrr-r.r| szHShapeEnv.create_symbolic_sizes_strides_storage_offset..c3s|]}|VqdSrKr-)rBsdrr-r.r| sNcss|]}|tjkVqdSrK)rrr,r-r-r.r|" srrrXcss|]}|dkVqdSrKr-rBrr-r-r.r|- scsBi|]:}|dk r|dkr||||qSrr-rBrP)ex_size ex_strider~rr-r.r. s  zIShapeEnv.create_symbolic_sizes_strides_storage_offset..cs$g|]}|dkr||fqSrKr-rrrr-r.r5 s zIShapeEnv.create_symbolic_sizes_strides_storage_offset..css|]}|dkVqdSrKr-rr-r-r.r|< scs$g|]}|dkr||fqSrKr-rrr-r.r? s ) dynamic_dimconstraint_dimcss|]}|dk VqdSrKr-rr-r-r.r|K sc s.g|]&\}\}}j||j|dqS)rr)create_symintnoder)rBrPsymr)rrrMrr-r.rM s r) rnrr~rrrfr_is_dim_dynamicrrrTrrrbr}rrrgrrrrrMrurxrrrrSTRIDErrSTORAGE_OFFSET)rMr~rrrZex_storage_offsetrfrPrZdynamic_strides_offsetr candidatesZval_listrZ sym_sizesZ sym_strideZ stride_exprZsym_storage_offsetr-) rrrrrrMr~rrr.,create_symbolic_sizes_strides_storage_offsets1         $       z5ShapeEnv.create_symbolic_sizes_strides_storage_offsetrz sympy.Expr)rrrcCstrD|dk rD||}|dk s$t||t}|t||nd}t|tj rt|dk rlt||ksltt|St t ||t||dS)Nr[) rrorgryrnrrrurrjrxrr)rMrrrrrr-r-r.rd s    zShapeEnv.create_symintnodecCs|j|j|||d||dS)N)rrr)rcreate_unspecified_symbol)rMvaluerrr-r-r.$create_unspecified_symint_and_symbol~ sz-ShapeEnv.create_unspecified_symint_and_symbol)rcCstt||tdSrK)rrry)rMrr-r-r.create_symboolnode szShapeEnv.create_symboolnodecCsjtdt|j}|jdd7<tjdd|j|<t |j |<| |t }t t||t d|dS)Nfcreate_unbacked_symbolr_rr[)rurrr`rhr&extractr[r#unknownrryrrrrMrrr-r-r.create_unbacked_symfloat s  z!ShapeEnv.create_unbacked_symfloatcCsntjdt|jdd}|jdd7<tjdd|j|<||j |<| |t }t t ||t d|dS)NrPTrrr_rr[)rurrrarhr&rr[ _default_unspecified_value_rangerryrnrrrr-r-r.create_unbacked_symint s  zShapeEnv.create_unbacked_symintcCsxtjdt|jdd}|jdd7<tjdd|j|<tdd|j |<| |t }t t t|d|t d|dS) NrPTrrr_rrr[)rurrrarhr&rr[r#rryryrrrrr-r-r.create_unbacked_symbool s  z ShapeEnv.create_unbacked_symbool)rrrrrcCs|j||||ddS)N)positive)r)rMrrrrr-r-r.r s z"ShapeEnv.create_unspecified_symbol)rrrrrrc Cst|ts tt|d||r:|dkr:td||dk rHtj}|tjkr\t|S|tj krn|j }n|tjkr~d}ntd||dkr|j r|j |}n<|r||j krtj dt|j|dd }|jd ||||jd d 7<t||j|<g|j|<||t|r2||j |<|rV||d k||j|<n||j|<t|tr|rzt|j||jM<|j|} || krt|d | jd| jd|}n|j |}|j d||t|tj r|j|!||S)Nrrz!positive set for negative value: Fzunhandled dynamic_dim rXr{Trrzcreate_symbol %s = %s for %srr_z not in range [r rzcreate_symbol %s duck sized %s)"rjrrgrmrrrrurxrrVrUr^rrrrr^rerrhrrprnrr_default_value_rangerrrrrJrrdebugrb) rMrrrrrduckrZ sympy_exprrr-r-r.r sL             zShapeEnv.create_symbolcCst|tr|jj|jj}}|}||jkr2d}||jkr@d}|d}|dk r~|dk r~|d|d|d|7}nR|dkr|dk r|d|d|7}n(|dk r|dkr|d|d|7}|S||S)Nz in the specified rangerr)rjrrrrrrr)rMrcrrdefaultZc_renderr-r-r.%render_range_for_constraint_violation s     z.ShapeEnv.render_range_for_constraint_violationcCs|SrKrrr-r-r.rz- r{zShapeEnv.)constraint_inputsequalities_inputs _simplifiedr)rrrc% sd jdt|t|ks t|dkr8dd|D}nt|t|ksLttt||D]j\}\} } t| tjr| dkrdg| ||<qt| | kstqZt| t t fstt| t rZtqZddl mmmgtt  tt  gd$fdd fdd d% fd d } t|||D]\} } } t| trbdd l m} | | } t| tsrt| dkrq8t| t t fr| | | q8t| tjstt| D](\}}| j|}| ||| |qt| D]\}}| | j||q| | j| q8gt jt  _ |sĈD]n\} }t!r| "}| j#kr $t%& j#||t|t%j'r (|r| |dkrqR|rt| rt|j)dkr j*d | d|qR| r j +| |t, j-.|}/ | d|t|t%j'rR| krRt| rR| j0jkrR|rR|1| |dsRd|2d | d|d}|j3|qRtt4dd fdd } j5D]$} 6|j7dk r q||q j89D]6\}}| kr8q"|D]}|dk r<||q<q"|s 9D]F\}} j:(|}|dkr j;|}|st|j<st j8(|d\}}g}|j=t%j> kr|dkrt?fdd|Dr j @t%A||j=|/t|j=|/ |d|jBt%j>kr|jBtCjDdkr|dkrt?fdd|Dr j @t%E||jB|/t|jBt|dkrh/dF|qhrfg}g}D]Z\}}|rdt|dd|}|/|n$dt|dd|}|/|qt|dkrHdF|}tGd|nt|dkrft*dt|tHd d jI jJttKd!d LDd"t!rXdd#lMmN}  jOLD]}!|!D]}" $|"j7qq j;9D]P\}#}$|$j=t%j> kr $t%E|$j=|#|$jBt%j>kr $t%E|#|$jBqtPQ| jR jSTW5QRX US)&Nproduce_guardscSs*g|]"}t|tjr"dg|ndqSrK)rjrGrrfrBrr-r-r.r? sz+ShapeEnv.produce_guards..r)rr NegateSourcecs|fddfdS)NcsrSSrKr-r-rrr-r.rz r{zNShapeEnv.produce_guards..record_constraint_violation..)rb)rrr)constraint_violationsrr.record_constraint_violation sz.record_constraint_violationcst|o|jjkSrK)rjpropr)src)rrr-r.is_dim sz'ShapeEnv.produce_guards..is_dimc st|tr"|jdk r"|j}t|tr*|jj}t|tjrh|||dk rf||nt| tjr| |nd}t|trd}n*t|t r|j rd}nt |}|dkrd}|rfdd} ||}d|d| d}|j|t||d ||fnt|}||fd}t|trXd}nt|t rr|dkrrd}|r ||}d|d| d |d }|j|dS) NFTrXcstj|}|dS)NzI. For more information about this inference, run with TORCH_LOGS=dynamic.)rrr0)r{r.)rMrrr-r.r sz;ShapeEnv.produce_guards..track_symint..hintNot all values of z are valid because z was inferred to be equal to rz was inferred to be a constant (zN). For more information about why it is constant, run with TORCH_LOGS=dynamic.)rjrrkr#rtrurrbrrr=rnrrrrpartialrx) rr constraintr{Zconstraint_violatedrPrvar_with_ranger)r input_guardsrrMrsymbol_to_constraintsrr-r. track_symint sV            z-ShapeEnv.produce_guards..track_symint LocalSourcezSkipping guard %sr z The specified set of equalities z( is not sufficient; please also specify r4guardrc sD|j}|jkrdS|zd}tfdd|jDrPj|}tj|} | |t |jdkr |s t |jd}|d}|}|D]T}t |tr||}d|d|d} |j| qt |trqtd |qWn2tk r>jd d |jYnXdS) NFc3s$|]}|D]}|VqqdSrKr-)rBr{r)rrr-r.r|F s z?ShapeEnv.produce_guards..issue_guard..r_rrz satisfy the generated guard zW. For more information about why this guard was generated, run with TORCH_LOGS=dynamic.zunrecognized constraint zFailing guard allocated at: %sr)simplifyrtr4rr=rfrrr0rbrqrrrcrjrrrrrgr]r^r_r rr) rrtZ is_trivialZ guard_exprrr constraintsrrr)r&rissuedrrMrrrr-r. issue_guard; s6          z,ShapeEnv.produce_guards..issue_guardNNc3s|]}|VqdSrKr-rBrrr-r.r| sz*ShapeEnv.produce_guards..r_c3s|]}|VqdSrKr-rrr-r.r| srz z. r!zConstraints violated! z$%s Warning only constraints violateddynamiccss|]}|rdVqdSr_Nr-)rBvr-r-r.r| s)Z num_guardsr=)PopulateValidator)N)N)Vr^rerrrgrMrrjrGrrfrrnrcrrrrrbrr-rrr~rrrrrrrrr!rfrrrjrqrurrrr=rrrrr0rbrrrrrrZ_maybe_evaluate_staticrtr\rrrrtrrrr4rrrErrr rJr'rWrhsumvaluesrrrc fx_tracebackZpreserve_node_metarrkrunrt)%rM placeholdersrrrrrrrPrrrrrssZproperty_sourcertrnr.rrrrrZrZg_lowerZg_upperZboundsZ warn_msgsZ error_msgsrerrrrasrarrr-) rrrrr&rrrrrMrrrr.r) s,  =  D            "-         *      zShapeEnv.produce_guardsrcslddlmddtt|D}|j|fdd|D|d}|rhd|}t|tdtt ||iSd S) NrrcSsg|]}d|qSrr-rr-r-r.r sz5ShapeEnv.evaluate_guards_for_args..csg|] }|qSr-r-rrr-r.r srz and LT) rrrrrrr rkr<dictr)rMrrPr arg_namesrZcoder-rr.r s  z!ShapeEnv.evaluate_guards_for_argscsifdd}t||D]\}}|dkr,qt|trB|||qt|tjsRtt|D]\}}||||q^t|D]\}}||||q|| | qS)Ncst|tr|jj}t|tjrT|krJ||ksRt|d|q||<nPt| tjr| kr| | kst| d| n | | <dS)N != )rjrrkrtrurrg)r+rr{Zbindingsr-r. bind_symint s  $  ,z*ShapeEnv.bind_symbols..bind_symint) rrjrrGrrgrMr~rr)rMrrPrrr+rPr{r-rr.r s   zShapeEnv.bind_symbolscsfddjDS)Ncs(g|] }|jdkr|jqSrK)rrtrrBrr r-r.r sz2ShapeEnv.get_nontrivial_guards..)rZr r-r r.get_nontrivial_guards szShapeEnv.get_nontrivial_guardscs&fdddfdd|jDS)Ncs&sdSdddd|DS)Nrz Guarded at: css|]}d|VqdS)z Nr-)rBlr-r-r.r| sz.format_tb..)r r)tb)verboser-r. format_tb sz)ShapeEnv.format_guards..format_tbr!c3s$|]}d|j|jVqdS)z - N)rtrr)rr-r.r| sz)ShapeEnv.format_guards..)r rZ)rMrr-)rrr. format_guards s zShapeEnv.format_guardscCs0tt}|jD]\}}|||q|SrK)rbrrcrrrb)rMZ shape_groupskrr-r-r.get_shape_groups s zShapeEnv.get_shape_groups) unbacked_only compute_hintzOptional[sympy.Expr])rtrrrcCs||}t|j}|D]b}||jkr(qi}|j|D]8}|rN|j|j}n|j}tj||<tj |t |<q6| |}qi} i} t |D]~\} } |j | } | jtj ddks|r| |jkr| | | <qtjd| ddd}| jd}||| | <t| | | |<qdd}z||| }Wn8tk rZtd|| |jd d7<Yd SXi}|tD]$}t|jd |jd||<qjt||}tt|jd kr|St|| }t||| r|jS|r|Sd S) z Tries to evaluate expr without introducing guards If unbacked_only == True, then we only do substitutions on unbacked SymInts (leaving regular hinted integers alone). r_rZshape_TrcSs ||SrK)r)rtreplr-r-r.rV sz0ShapeEnv._maybe_evaluate_static..replacez(RecursionError in sympy.xreplace(%s, %s)sympy_recursion_errorNr)!rrcr=rrcrtrrur)r*Notr rMrrrErrr"r4rwr^r_rhr'rrJrPrxrrr!rZ is_singleton)rMrtrrrr{Zsubstrr1Z new_shape_envZ new_range_envrrroffsetrnew_exprZfloor_div_replacer(rr-r-r.r s^        "   zShapeEnv._maybe_evaluate_static)rtrcs"fdd|jD}t||S)Ncs i|]}|ttj|qSr-)rr rurrzr r-r.rt sz$ShapeEnv.replace..)r=rxr)rMrtrr-r r.rr szShapeEnv.replacecCs>t}|jD]&}||}t|jdkr ||q ||_dSr)rr]rrrr=r4)rMZ new_divisiblerresr-r-r._update_divisiblew s    zShapeEnv._update_divisiblecCsf||}|tr|i}|tD]^}|j\}}t|tr*|j\}}|t|||jkr*||kr*|t|||jkr*|||<q*| |}t |}|trbi}|t j }|t j |t j} |tD]0} | j\}}|t|||jkr|||| <q| |} t | } | t j } | t j | t j} | |rb| | rb| }|SrK)rrrrr'rPrjrr]rrxrurRational differencerxissubset)rMrtZdiv_replacementsr(riroZbase1Zdivisor1ZpowsZ rationalsfdrZnew_powsZ new_rationalsr-r-r.r s>            zShapeEnv.simplifyrur,cCsHt||j}t|jdkrD|j|dd}|dk r8|S||||S)a Gets a size hint for a given expression from the underlying shapes we had. Does not introduce a guard, so only use this when you can guarantee that your code is still valid for arbitrary shapes (such as optimization decisions) rT)rN)rxrrrrr=rr")rMrt result_exprrr-r-r. size_hint s zShapeEnv.size_hintcCs,t||j}t|jdkp*||dk Sr)rxrrrrr=r)rMrtrr-r-r.rs szShapeEnv.has_hintcCsF|jD](}d|j|}|jd||qtd|d|dS)Nrz-Data dependent variable '%s' allocated at: %szIt appears that you're trying to get a value out of symbolic int/float whose value is data-dependent (and thus we do not know the true value.) The expression we were trying to evaluate is z (unhinted: zU). Scroll up to see where each of these data-dependent accesses originally occurred.)r=r r[rr^rr()rMrtZ unhinted_exprr{Z stacktracer-r-r.r" s  z#ShapeEnv._make_data_dependent_errorz sympy.Symbol)rprtrcCstjjjrbt|tjtjfrb||jks4||j|krb|j d|j |d ||j j ddd||j|<|t||dS)zx Adds or updates a replacement for a symbol. Use this instead of `self.replacements[a] = expr`. zSpecializing %s to %srZSPECIALIZATIONT stack_infoN)rG_dynamoconfigZprint_specializationsrjrurxr(rr^r_rrrrqr)rMrprtr-r-r._set_replacement s  zShapeEnv._set_replacement)rprcsN|jkr|Sj|}fdd|jD}|j||j|S)z Implements a DSU-like algorithm to find the variable that represents a Also handles transitive non-identity replacements. a: b + c c: d csi|]}||qSr-rrzr r-r.r sz"ShapeEnv._find..)rr=rr)rMrprZ cur_replacer-r r.r s  zShapeEnv._find)zsympy.Eqzsympy.Ne)rt concrete_boolrc st|tkstt|tjr&|s:dSnt|tjr:|r:dSt|j}t |dks^td|t |dkrndSt |fdddd}|j }|j }| tsz|t|t}t |dkrtd d |Drtt||dd d }|dk r6td d t|dDr6|d}ttj|d|WnRtk rNYn>tk rjdd7<jd|||dYnX| trt|td} z6t|| d d }|dk r|ddkrވj !| Wntk rYnXdS)z Evaluates the result of an eq call. If true, uses information to simplify shapes (i.e. a == b or a % 5 == 0) Nrz3The expression should not be static by this point: cs||jfSrK)rrrr r-r.rz r{z*ShapeEnv._maybe_guard_eq..T)rreversecss|]}|jdkVqdSr)rorr-r-r.r| sz+ShapeEnv._maybe_guard_eq..F)Zfloordiv_inequalitycss|] }|jVqdSrK)rtrr-r-r.r| sr_rz*RecursionError in sympy.solve(%s - %s, %s))"rmryrgrjrurrrcr=rrrrrrrr'runionrrLr r}Zpreorder_traversalrrr rrwrhr^r_rr]r4) rMrtrfreerrZfloor_div_atomsrrmod_exprr-r r._maybe_guard_eq sJ     ( zShapeEnv._maybe_guard_eqcCs|jr dnd}t|tjdSr)rUr#rEr)rMrr-r-r.r& szShapeEnv._default_value_rangecCsttj dtjSr)r#rErr r-r-r.r* sz)ShapeEnv._default_unspecified_value_rangecCsPt|t}t|D].}|j\}}t||}t|d}||q| |Sr) rr'rrarPrrurr\r)rMrtZ floor_divsrrirorZeq_exprr-r-r.r- s     zShapeEnv._simplify_floor_divcCsL|jrH|jdd7<tdd|j|d|ddtd||dS) NZignored_backward_guardr_rZevaluate_expr_frozenr r)Z ignored_guardversionz>Ignored guard %s == %s, this could result in accuracy problems)rrhr'rWr^r_)rMrt concrete_valr-r-r. _check_frozen= s  zShapeEnv._check_frozen)prefixc Cs|jtjrd}t}z<|dk rT|jjtkrLt |jj|j |jj }qT|j }qW5~Xd}t}|r|dt|d}|jtj}d}|r|rddt |}|jjd||t|||ddS)Nrz at r`zM User Stack (most recent call last): (snipped, see stack below for prefix) zeval %s [guard added]%s (%s)%sr)r^ isEnabledForloggingINFOr@rrrrI traceback FrameSummaryrco_namerr extract_stackr%DEBUGr  format_listre) rMr gZfsummaryrZmaybe_user_locZuser_tbZis_debugZmaybe_extra_debugr-r-r. _log_guardN sB zShapeEnv._log_guard)rcCs|dkr||}n t|}d}d}tr|dk r|s|tjkr\|tj|f\}}n^|tj kr|t j |f\}}|tj|f\}}n*|t j ||f\} }|tj| f\}}d} d} zt |jdkr|jd|t|ttfr||kst|d||WS|} || } | dk rp|jd|| t|ttfrj| |ksjt| d|| WS| j|jks|j| dd}|j|jks|| |j| |} || |tjjjrt|trt| tjtjfrt | } t| tjtjfr"|!| t|n"t|tj"rD|!t| |d|tjkrV| }n$|tj krnt | }n t| |}|st#j$d d }t%||} |j&'| Wn(t(k r|r|)|Yn@X|s| dk st|*| |+d |n|jd ||S) zO Given an expression, evaluates it, adding guards if necessary NFrzeval %s [trivial]rz eval %s == %s [statically known]Trr_rrkzeval %s [guard suppressed]),rrurrr}r)rrG_assertr*rnot_rDrrr=r^rrjrnryrgrrr!r"rr rrZ/inject_EVALUATE_EXPR_flip_equality_TESTING_ONLYrrrrrxr&rrrZrbr]rz refine_rangesr)rMrrrr rkrxrNrZeqlrrrt static_exprrrrr-r-r.r\w s                   zShapeEnv.evaluate_exprcCsV|jD]}|jq|jD] }|q |jD]}|D]}|jq@q8dSrK)rZrcleanupr[rrc)rMrr{rrr-r-r.r s   zShapeEnv.cleanupc Cs|}||}|dk r*|jd|||S|j|dd}|j|jkrV|j||dStr||dk r||s|| t j |f| |t j|stjdd}t|||}tdd|jDd d d } |j| d ||jd7_|d |n|jd|dS)Nz*runtime_assert %s == %s [statically known]Trr[r_rcSsg|]}|jdr|qS)rP)r startswithrzr-r-r.rs z1ShapeEnv.defer_runtime_assert..cSst|jddSr)rnr)r{r-r-r.rzr{z/ShapeEnv.defer_runtime_assert..rr`Zruntime_assertz$runtime_assert %s [guard suppressed])rr^rr=rr!r\rr}rrGrr rur)r&rrrrcrbrdr) rMrrrrtrrrrcandsr-r-r.rc s2   zShapeEnv.defer_runtime_assertrc CsL||j}|jD]2}t|tjs(tt||}|dks|jr|djsLq|\}}|j |}|j |j }} t ||j } t || |j|d\} } || j krt|tjtjtjfr| j tt|tj}|} | | j kr t|tjtjtjfr | j tt|tj} |} |t|| krqt|| |j |<| | f|j|<|jqdS)Nr_r)rrtr=rjrurrgr rtrrrr!rr\rrrrrnrrr#rr) rMrrtrrZr_exprrrrrZrhs_vrZ lower_guardZ upper_guardr-r-r.r4s.       $zShapeEnv.refine_ranges)F)NN)N)Qr*r+r,rrmrr rurrorrprqrrrtr rrGrrvryrryrzr}rr{rrDimListr DimConstraintr rrrnrrrrrrrrrrrr InputListrrr-rrrrrrrrrrrrrrsr"rrrr#rrrr rr\rrcrrr-r-r-r.r3s   {             N%   , / V %5 )u ;cCs(t|tsdSt|jjjdkr$dSdS)NFrT)rjrrrrkrtr=r,r-r-r._is_intfs  r#cCst|do||jkS)N_dynamo_dynamic_indices)rUr$)rrr-r-r.rnsr)NN)r)N)rrbrr@rrrrr6rE threadingrr contextlibr dataclassesrrenumrrtypingrr r r r r rrrrrGZtorch.fxZtorch.fx.tracebackrrrrrrrrrZ torch._guardsrrrZtorch.utils._sympy.functionsrrrrZtorch.utils._sympy.solver Ztorch.utils._sympy.value_rangesr!r"r#r$Ztorch.utils._tracebackr%r&Ztorch._utils_internalr'r"r rr getLoggerr*r^rVr(ruZsympy.printing.strr/Zsympy.printing.precedencer0Z_opsZopsZaten__all__rIrTrJr5r1r2rir;rsrnr4ryr?rrrr=r>rrrrrr8rrrrrrr6r7rrrrrrrrrrrrr!rrFunctionrrnrpZIndicatorTypesrxrrrrrZ magic_methodsZsizes_strides_methodsrrrrrrrrrrrsrrZbool_magic_methodsrrrr:rDrErFrGrHrIr:r@r>rJrMr<rrrr9rrrrrNrrrrrrrrrAr|r3r#rr-r-r-r.s    0$                &E<  ,%    #   VG     "