tjR UddlmZddlZddlmZddlmZmZmZ ddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddl mZmZddlmZmZmZmZm Z ddl!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'dd l(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6ddl7Z7ddl8Z7ddl9m:cmZ;ddlZ?dd l7m@Z@mAZAmBZBdd lCmDZDmEZEmFZFddlGmHZHmIZImJZJmKZKddlLmMZMddlNmOZOddlPmQZQmRZRmSZSmTZTddlUmVZVddlWmXZXddlYmZZZddl[m\Z]ddl^m_Z_ddl`maZambZbmcZcmdZdmeZeddlfmgZgmhZhddlimjZjddlkmlZlddlmmnZnddlompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzddl{m|Z|ddl}m~Z~mZddlmZdd lmZdd!lmZmZmZmZdd"lmZmZmZmZdd#lmZmZe0r ddlZdd$l7mZdd%lmZdd&lmZdd'limZmZmZeZeZejeZdd(lmZmZdjd-Zdkdld2ZGd3d4eZGd5d6eZGd7d8eZe7jjjZgd9Zd:Zd;Zdmd?Zd@ZdAedB<e3dCZe3dDejeejZGdEdFZdndJZdodMZeddpdOZGdPdQeZdqdUZe7jBezZdAedV<drdZZe7jBe7jAze7j@zezezezZdAed[<dsd\Zdtd^ZÐdud`ZĐdvdbZŐdwddZe5deeǬfdxdiZȐdydlZɐdzdqZe7jee7jdrfzZdAeds<d{dwZ͐d|dyZΐd}dzZ d~ddZАddZѐddZҐddZeBeAze@zezezezejze7jzZdAed<ee ezZdAed<ddZ֐ddZאddZؐddZِddZڐddZېddZܐddZݐddZe&d{d{GddZe&d{d{GddZe&d{d{GddZe&d{d{GddZe&d{d{GddZ dddZ dddZddZdvdZdvdZddZddÄZddĄZddńZddDŽZddɄZddʄZdd̈́ZddτZddфZ dddԄZdd՜ddքZddلZdddۄZdvd܄Zdd݄Zdd߄ZddZddZd{dddZddZGdde)Ze&d{d{GddZe&d{d{GddeZe&d{d{GddeZeezdzZe&d{d{GddeZddZddZddZe&d{d{GddZe&d{d{GddeZe6dZ e3dZ e&d{d{Gddee-e e fZ e&d{d{d{Gdde dre+fZ e&d{d{Gdd e Z e&d{ Gd d ZddZevfZddZddZedddZGdde.ZedddZddZdd#Zdd$Zdd%Zdd)Zdd*Zeeee7d+Z dkdd/Ze&d{d{Gd0d1ZGd2d3eZGd4d5ej Z!Gd6d7e!eZ"e5d8eǬfGd9d:e"Z#Gd;d<e!e~Z$e&d{d{Gd=d>Z%e&d{d{Gd?d@e%Z&GdAdBe"Z'GdCdDeZ(GdEdFZ)ej*Z+ddGZ,ddHZ-e#ddJZ.e&d{d{GdKdLZ/e&d{ GdMdNZ0e#ddPZ1e&d{ GdQdRZ2GdSdOZ3ddTZ4ddWZ5GdXdYe7j:j6Z7dd[Z8dd`Z9GdadbeZ:ddeZ;ddfZdS() annotationsN)S)BoolLike FloatLikeIntLike)Counter defaultdict)Callable GeneratorIteratorMappingSequence)_GeneratorContextManagercontextmanager)asdict dataclassfield)Enum) AnycastGeneric NamedTupleNoReturn TYPE_CHECKING TypeAlias TypeGuardTypeVar) deprecated ParamSpec)SymBoolSymFloatSymInt) get_unwrappedis_batchedtensoris_gradtrackingtensor) ShapeGuardSLocSourceTracingContext)FakeScriptObject)is_opaque_value)dtrace_structured LazyString structuredtrace_structured) OpaqueBase) is_sparse_any)signpost_event)_config)AggressiveGuardFreeMode)FakeTensorMetarecord_shapeenv_eventreplay_shape_env_eventsshape_env_check_state_equal ShapeEnvEvent)SymNodeSymTypes) py_sym_types) OrderedSet)is_traceable_wrapper_subclass) Application CeilToIntCleanDivFloorDiv FloorToInt IntTrueDiv!IsNonOverlappingAndDenseIndicatorMaxMod PythonMod TruncToInt)int_oo) CppPrinter PythonPrinter SingletonInt) try_solve) make_symbol prefix_strsymbol_is_typeSymT) bound_sympySymPyValueRangeAnalysisValueRangeError ValueRanges)CapturedTraceback format_frame)TensorTensorPropertySource FakeTensor) BoolLikeType FloatLikeType IntLikeType)_guarding_hint_or_throw_base_optimization_hint_basea3torch.SymInt | torch.SymBool | int | bool | SymNodereturn int | boolct|trL|j|jS|jt d|j|j}||_|St|tjtj frt |j St|tr|St|turt dt||S)z Return a concrete hint for a symbolic value, for use in guarding decisions. Returns Python bool (True/False) for boolean inputs (SymBool, bool), and Python int for integer inputs (SymInt, int). Nz0shape_env is required for guarding_hint_or_throwExpected int, got ) isinstancer:_hint shape_envAssertionErrorguarding_hint_or_throwexprtorchr"r nodebooltypeint)rdhints c/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/fx/experimental/symbolic_shapes.pyrnrns!W 7 7N ;  !STT T{11!&99 !elEM233.%af---!T Awwc;$q'';;<<< Htorch.SymInt | intfallback int | Nonertc*t|tjrC|jj |jjS|jj|jj|St|turtdt||S)z Return a concrete hint for a symbolic integer, for use in optimization decisions. Unlike guarding_hint_or_throw, this function does not add guards and is intended for optimization purposes only (e.g., memory estimation). N)ryri) rjrpr"rqrkrloptimization_hintrorsrtrm)rdrys rvr|r|s!U\""R 6< #6< v11!&+1QQQ Awwc;$q'';;<<< Hrwc,eZdZUded<dfd ZxZS) GuardOnDataDependentSymNode sympy.BasiccondargsrrfNonecBtj|||_dSN)super__init__r)selfrr __class__s rvrz$GuardOnDataDependentSymNode.__init__s"$ rw)rrrrrfr)__name__ __module__ __qualname____annotations__r __classcell__rs@rvr~r~sKrwr~ceZdZdS)PendingUnbackedSymbolNotFoundNrrrrwrvrrDrwrceZdZdZdS)_ShapeEnvGuardErrorzNRaised when a guard is attempted while the ShapeEnv is in error-on-guard mode.Nrrr__doc__rrwrvrrsXXXXrwr),r|rnguard_or_false guard_or_truehas_symbolic_sizes_stridescreate_contiguousShapeEnvis_concrete_intis_concrete_floatis_concrete_boolhas_static_value guard_int guard_float guard_scalarcanonicalize_bool_expr SYMPY_INTERP free_symbolsis_symbol_binding_fx_node is_nested_intSHAPEENV_EVENT_KEYCURRENT_NODE_KEYhas_free_symbolshas_free_unbacked_symbolssym_andsym_eqsym_orSymbolicContextStatelessSymbolicContextStatefulSymbolicContextSubclassSymbolicContextSymIntSymbolicContext TrackedFakestatically_known_truestatically_known_falseguard_size_obliviouscheck_consistentcompute_unbacked_bindings ConvertIntKeyrebind_unbackedresolve_unbacked_bindingsis_accessor_nodeValueRangesSLocSymIntEqByExprSpecializationshapeenv_event current_node wrapped_f$functools._lru_cache_wrapper[object]rcltd|j|dS)Nzlru_cache_stats %s: %s)logdebugrcumulative_cache_info)rs rvlog_lru_cache_statsrs:II ''))rwzsympy.logic.boolalg.Booleanr SympyBoolean_T_SympyTcJeZdZdZeddZddZdd ZddZddZ dS)ra This is a wrapper around SymInt which has alternative semantics for equality and pickling. Specifically, instead of erroring or guarding, we instead will hash/compare equality based on the underlying sympy expression; e.g., s0 and s1 will always compare as False. NB: This does NOT do fancy analysis that maybe_evaluate_static does; we can only reason through equalities that occur because to expressions canonicalize to the same expression via regular simplification. valrxrf sympy.Exprcvt|tjr |jjSt j|Sr)rjrpr"rqrosympyIntegerrs rv_extractzSymIntEqByExpr._extracts0 c5< ( ( &8= =%% %rwrcDt||_dSr)rrr)rrs rvrzSymIntEqByExpr.__init__ s-66s;;rwstrc*t|jSr)reprrrs rv__repr__zSymIntEqByExpr.__repr__#DH~~rwotherobjectrrct|tstdt||j|jkS)NzExpected SymIntEqByExpr, got )rjrrmrsrrrs rv__eq__zSymIntEqByExpr.__eq__&sA%00 P !Ne!N!NOO Ox59$$rwrtc*t|jSr)hashrrs rv__hash__zSymIntEqByExpr.__hash__+rrwN)rrxrfr)rrxrfrrfrrrrfrrrfrt) rrrr staticmethodrrrrrrrwrvrr s  &&&\& <<<<%%%% rwrtuptuple[IntLikeType, int]tuple[int, IntLikeType, int]ct|dr(d|dj|dfndg|RSNr)rrqnested_int_coeff)rs rv_nested_int_aware_sortr/sJ Q  CFK ( ( * *CF33Y#YY rwmaxsize?Callable[[Callable[..., _T]], functools._lru_cache_wrapper[_T]]cdfd }|S)NfCallable[..., _T]rf functools._lru_cache_wrapper[_T]ctj|jdddfd }dfd }|_|_tt jrtj tS) Nrrffunctools._CacheInfoc}tj|jz|jz|j|jSr) cache_info functools _CacheInfohitsmissesrcurrsize)cur prev_hits prev_missesrs rvrz7lru_cache..inner..cumulative_cache_infoIsG&&((C'CH$cj(   rwrcl}|jz |jz dSr)rrr)rold_cache_clearrrrs rvnew_cache_clearz1lru_cache..inner..new_cache_clearRs@&&((C  !I 3: %K O     rw)rfrrfr) r lru_cache cache_clearrr isEnabledForloggingDEBUGatexitregisterr)rrrrrrrrs @@@@rvinnerzlru_cache..inner?s0I'0033 #/                   !0 *? '   GM * * < O/ ; ; ;rw)rrrfrr)rrs` rvrr<s)@ Lrwset[str]cddl}ddl}ddl}ddl}ddl}ddl}ddl}ddl}ddl}ddl }tj t|j j|jjj|jjj|jj|jj||j|jj|jj|jj|jj|jj|jj|j j!|j j"g}ddl#}d|D}tHj%&|j'j(}tSj)tHj%*|d}|tW|z|jj,-zdhzS)Nrc6h|]}tj|Sr)inspectgetfile).0ms rv z&uninteresting_files..s" . . .AW_Q   . . .rwz*.py).torch._compiletorch._dynamo.eval_frametorch._higher_order_opstorch._inductor.sizevarstorch._library.custom_opstorch._library.fake_impltorch._loggingtorch._subclasses.fake_tensortorch._subclasses.meta_utilstorch.export._tracesysmodulesrexport_tracefx experimental recordingsym_node interpreter_symbolic_trace_compile_dynamo eval_frame _inductorsizevars_library custom_ops fake_impl _subclasses meta_utils fake_tensor_logging _internalr.torch._dynamo.guardsospathdirname_higher_order_ops__file__globjoinsetguardsuninteresting_files)rpmodsfileshigher_order_ops_dir hop_filess rvrCrCds####""""####$$$$####(((('''' H  ' &          !   $ %   !! D$  . . . . .E7??5+B+KLL "',,';VDDEEI  i..  -  2 2 4 4 5 , rwceZdZdS)ConstraintViolationErrorNrrrwrvrIrIrrwrIelem torch.Tensorrrc|jSr)_has_symbolic_sizes_strides)rJs rvrrs  ++rwIntshape Sequence[Int] list[Int]cdg}t|ddD] }|||dz!tt|S)Nr)reversedappendlist)rOstridesdims rvrrs\Gcrc ##**sWR[()))) !! " ""rwScalarcbt|tr|jSdS)z Check if a symbolic value has a hint available for guarding. Returns True if the value is concrete or if the symbolic node has a hint, False otherwise. T)rjr;rqhas_hintrds rvhas_guarding_hintr]s-!X!v   4rwrac t|ttfstdt |t|trdSt|jjtjj j rdSdS)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 zExpected SymInt or int, got TF) rjr"rtrmrsrqrorcorenumbersrr\s rvrrsw a&# ' 'GEDGGEEFFF!St!&+uz19::t 5rwr`c t|ttfstdt |t|trdSt|jjtjj j rdSdS)zUtility to check if underlying object in SymInt is concrete value. Also returns true if integer is passed in. Args: a (SymInt or float): Object to test if it float z Expected SymFloat or float, got TF) rjr!floatrmrsrqrorr_r`Floatr\s rvrrsx a(E* + +KIQIIJJJ!Ut!&+uz1788t 5rwr_c6t|ttfstdt |t|trdSt|jjtjj j tjj j frdSdS)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 zExpected SymBool or bool, got TF) rjr rrrmrsrqrorlogicboolalg BooleanTrue BooleanFalser\s rvrrs a'4 ) )IGd1ggGGHHH!Tt  ek)5u{7J7WXt 5rw0SymBool | SymFloat | SymInt | bool | float | intcDt|ttztzst dt |t|trt |sHt|trt|s$t|trt|rdSt|tst dt ||j j |j j S)z User-code friendly utility to check if a value is static or dynamic. Returns true if given a constant, or a symbolic expression with a fixed value. Args: a (Union[SymBool, SymFloat, SymInt, bool, float, int]): Object to test z)Expected BoolLike/FloatLike/IntLike, got TzExpected py_sym_types, got )rjrrrrmrsrrrr<rqrlrTro is_singletonr\s rvrrs  aI-7 8 8TRaRRSSS1h Q   a # # a  a ! !  A   t a & &FD477DDEEE 6  ' ' 4 4 A A C CCrwzguard_size_oblivious will be removed. Consider using explicit unbacked handling potentially utilizing guard_or_false, guard_or_true, or statically_known_truecategoryrotorch.SymBool | boolct|tjr|jddSt|t st dt||S)a Perform a guard on a symbolic boolean expression in a size oblivious way. This is typically used when a non-oblivious test would result in a guard on a data dependent value of which we don't know the value of at compile time. When a guard is tested this way, we may diverge in behavior from how regular PyTorch semantics would treat it. For more information, see https://github.com/pytorch/pytorch/pull/118579 rExpected bool, got )rjrpr rqrrrrmrsros rvrr se$ &&y--b!444$%% E !CtDzz!C!CDD D rwnewoldctjtjttf}t tjrt tjstdttj  kfdtj j D]"\}}tj ||kfd#dSt |rmt tsZt |rt trtdtj kfddSdSdS)z Test that two "meta" values (typically either Tensor or SymInt) have the same values, e.g., after retracing. If we don't understand the quantities in question, we'll just skip the consistency check. Expected Tensor, got c(jdjdSN != z (old != new)rOrsrtsrvz"check_consistent..1ssy,V,Vci,V,V,Vrwc(jdjdSrxrzr{srvr|z"check_consistent..8sCI)S)S39)S)S)SrwrycddSrxrr{srvr|z"check_consistent..=sC)G)GS)G)G)GrwN)rpr"r!rtrbrjrZrmrs_checkrXziprOrr)rsrt scalar_typesijs`` rvrr#sL%.#u=L#u|$$I#u|,, F !Dc!D!DEE E GGII "$V$V$V$V$V    39-- U UDAq La!S!S!S!S!S T T T T U U C & &Iz#t/D/DI3 -- 4jd6K6K 4 C!2!2S!2!233 3 SCZ!G!G!G!G!GHHHHHIIIIrwrlShapeEnv | Nonebindings)dict[sympy.Symbol, pytree.KeyPath] | Nonecn|dStdfd|DS)a When we do fake tensor prop, we oftentimes will allocate new unbacked symints. We then run proxy tensor mode, which populates node.meta["unbacked_bindings"] with these new symints. To ensure consistency we use PropagateUnbackedSymInts to rename unbacked bindings to their old ones. But all of the node metas are still using the old bindings from before the renaming. This function helps to post facto apply any renamings discovered in the PropagateUnbackedSymInts pass. Nshape_env should not be NonecNi|]!\}}j|||"Sr)unbacked_renamingsget)rkvrls rv z-resolve_unbacked_bindings..Ps2 S S S$!QI ( , ,Q 2 2A S S Srw)rmitems)rlrs` rvrr@sIt;<<< S S S S(..BRBR S S SSrw.Resultn torch.fx.Noderesultch|jdkrdSt||jdx}rw|t d|D]R\}}t j||}t|ttfr$t d|j |||[|jjh|jj}t|t"jr^t'|jdkrEt+t,t"jt"jf|jdx}r|ddkrt|dx} t"jrt| jx} t"jr|j| t;ddr| jdkr~t+t,t"jt"jf|jdd kr>t?t#j| d} | |krt | d || }t|t"js|j rt d |"||krt |d |!||RdSdS) a Suppose we are retracing a pre-existing FX graph that previously had fake tensor propagation (and therefore unbacked SymInts). When we retrace, we re-propagate fake tensors, which results in new unbacked SymInts. When this happens, we need to tell the shape environment about the equivalence of the old and new unbacked SymInts. Pass us the old torch.fx.Node (which has the old binding information) and the new result (which we can extract the new unbacked SymInts out from). placeholderNunbacked_bindingsrz'rebind_unbacked: discard %s %s %s -> %srrrTryz#should have been constant, but got z possible memo disaster)"oprmetarrmrpytreekey_getrjrtrbrinfotargetrqru_exprr PiecewiselenrrtupleBasicEqlhsSymbol var_to_rangeissubsetrWrhs'_sympy_cast_symbool_to_symint_guardlessr_rename_unbacked_to) rlrrrraw_u0r;u1raw_u1 raw_u1_args0eq new_raw_u1repackeds rvrrVs t},16::122xu:   !?@@ @$NN,,p :p :LFD--BV"sEl++ =H w|' W]F 65?33 $ $$))$(ek5;67Q%%L* !Oq((\!_4reh??)RV3zU\BB)*:6?? Aq@Q@QRR)FaKKu{EK78&+a.IIYVVCHZ++v%%(H)B)B&)B)BCCC$fel33 &Y()Wv)W)WXXX$%G%G%GHHH  ) )&& 9 9 9 9ku:u: p :p :rwrqc |jdkrrt|jdtjjrHt|jdjdtjr |j dvrdS|jdkr|j tj j j tj j j j tj j j jtj j jtj j jj tj j jjtj j jtj j jj tj j jj f vrdSdS)z Helper function to determine if a node is trying to access a symbolic integer such as size, stride, offset or item. Currently primarily only used in a DCE pass to figure out purity. call_methodr example_value)sizestridestorage_offsetitemT call_functionF)rrjrrpr&NoderrrZropsatensym_sizedefaultrt sym_stridesym_storage_offset sym_numelrqs rvrrs =  ty|UX] 3 3 ! ty|(,,_==u| L L ! KG G Gt w/!!dk  ' # ! !) !% ) )1  ( 6 ' 't 5rwc rt|tjtjtjtjtjtjfs|St|tjtjtjfr$tjj |}t|S)a Canonicalize a boolean expression by transforming it into a lt / le inequality and moving all the non-constant terms to the rhs. We canonicalize And / Ors / Not via cnf and then canonicalize their subexpr recursively nb. sympy.Rel.canonical is not good enough https://github.com/sympy/sympy/issues/25924 Args: expr (sympy.Expr): Expression to canonicalize ) rjrRelAndOrNotrNererfto_cnf_canonicalize_bool_expr_implrrs rvrrs"  uy%)UXuy%(EHM   $EHei8990{"))$// ' - --rwTclstype[sympy.Add | sympy.Mul]rlist[sympy.Expr]sortis_commutative bool | Nonerc|s|jS|r|tjurtjjj}n7|tjurtjjj}ntd||durtd|dj r6|dd}||| |dg|z|S| }||| ||S| ||S)a Create a sympy expression from a list of arguments, optimizing for performance. This function creates a sympy Add or Mul expression from a list of arguments while avoiding expensive operations like flattening. It handles sorting the arguments appropriately based on the expression type. Args: cls: The sympy class to create (Add or Mul) args: List of sympy expressions to combine sort: Whether to sort the arguments (default: True) is_commutative: Whether the operation is commutative (default: None) Returns: A sympy expression of type cls combining all arguments Raises: ValueError: If cls is not sympy.Add or sympy.Mul z Unknown cls: Tzis_commutative must be TruerrNr)identityrAddr_add_addsortMulmul_mulsort ValueErrorrm is_Number _from_argscopy)rrrrsort_fnrests rv_sympy_from_argsrs4 | C %)  jn-GG EI  jn-GG2S2233 3  % % !>?? ? 7  G8D GDMMM>>47)d"2>>RR R99;;D GDMMM>>$~>FF F~~d>~BBBrwcZt|tjtjfr*t |t t |jStjtj tj tj i}t|t| r%|j|jz }|t |}nyt|tj tj tjtjfst%dt ||j|jz }t |}d d}t&j}t+|}t|tjrg}g}|jD]9}||r|| $||:t1tj|dd }t1tj|dd }n||r| t&j}}|||d S) z After canonicalization, we are guaranteed to have eliminated Ge/Gt relations (rewriting them to Le/Lt, respectively). zExpected Lt/Le/Eq/Ne, got trrfrrc|jr|jp=t|tjo#|jdjo|jdjSNr)r is_negativerjrrrrs rvis_negz,_canonicalize_bool_expr_impl..is_neghsC -  q%) $ $ V)< VAV rwFTrrevaluate)rrrfrr)rjrrrrsmaprrGtLtGeLerkeysrrrrrmrZero_reduce_to_lowest_termsrrUr) rooppositerrrrposnegterms rvrrUs $EH-..CtDzz35tyAABB%(EHeh7H$hmmoo..//h! T$ZZ $58UXux HII L !Jd4jj!J!JKK Kh! JJ    &C !# & &C#uy!! H ! !Dvd|| ! D5!!!! 4    uy#E$OOOuy#DNNN  4S 1S# & & &&rwcd d}d d|jrtttj|j}t jtj t||dkr|Sfd |D}ttj |d |j S|jr tjS|jr|||S|S)z Eliminates any integer factor from a given expression. E.g., 6x + 4y reduces to 3x + 2y. Useful when an expression is == or != to 0. xrrfrtc|jrtt|S|jr;|jdjr'tt|jdndSdSr) is_Integerabsrtis_Mulrrs rvinteger_coefficientz4_reduce_to_lowest_terms..integer_coefficients\ < s1vv;;  X +,&)*>E3s16!9~~&&&A E1rwfactorcN|jr||z S|jr|jd|kr3|jdtj|z g|jdd}nt |jdd}t tj||jStd|)Nrrrzillegal arg to div_by_factor: ) rrrrrrVrrrrm)rrrs rv div_by_factorz._reduce_to_lowest_terms..div_by_factors < Gv:  X GvayF""q EM&$9$99GAF122JGAF122J''#EItADTUUU U !E!!E!EFF Frwrc(g|]}|Srr)rrrrs rv z+_reduce_to_lowest_terms..s%999aq&))999rwTr)rrrfrt)rrrrtrfr)is_AddrrrExprrrreducemathgcdrrrrrrOner)roratomsrrs @@rvrrs G G G G { >Xej)4955!$(C0CU,K,KLL Q;;K999995999 Iu48K     >u >}T#6#6t#<#<=== KrwsIntLikeType | FloatLikeTypeTypeGuard[SymInt]cht|tjo|jSr)rjrpr"rqrr s rvrrs' a & & A16+?+?+A+AArwIterateExprsAtom IterateExprsrIterator[sympy.Basic]c#Kt|tr!t|r|jjVdSdSt|t r |jVdSt|t jr|VdSt|ttttfrdSt|ttfr|D]}t|Ed{VdSt|trSt!j||D]}t|Ed{VdSt)|r)t|Ed{VdSt|t,jrwt|Ed{Vt|Ed{Vt|Ed{VdS|dSt|t,jst7|rdSt|t8rdSt;d|dt=|)a Recursively iterate through a value and yield all sympy expressions contained within it. This function traverses various data structures (tensors, lists, tuples, etc.) and extracts any symbolic expressions they contain. It's used for operations like finding free symbols in complex nested structures. Args: val: The value to extract sympy expressions from. Can be a symbolic type (SymInt, SymFloat, SymBool), a sympy expression, a primitive type (int, float, bool), a container (tuple, list), a sparse tensor, a regular tensor, None, or a torch.Generator. Yields: sympy.Basic: Each sympy expression found in the value. Raises: AssertionError: If the value is of an unsupported type. Nz&cannot extract sympy expressions from  )rjr; is_symbolicrqror:rrrtrbrrrrrV_iterate_exprsdict itertoolschainrvaluesr1rrprZrrr r+r*rmrsrr s rvrrs,#x  Y s   (-       C ! !Yh C % %Y C#udC0 1 1Y  C% ' 'Y ) )A%a(( ( ( ( ( ( ( ( ( ) ) C  YSZZ\\:: ) )A%a(( ( ( ( ( ( ( ( ( ) ) s  Y!#((**----------- C & & Y!#((**---------!#**,,/////////!#"4"4"6"677777777777   C ) )Y_S-A-AY  C) * *Y WcWWDQTIIWWXXXrwrIterator[SymNode]c#lKt|tr|VdSt|trt|r |jVdSdSt|t t tjfr|D]}t|Ed{VdSt|tj rt| Ed{Vt|sRt| Ed{Vt|Ed{VdSdSdS)z] Recursively iterate through a value and yield all SymNodes contained within it. N)rjr:r<rrqrrVrpSize_iterate_nodesrZrr1rrrs rvr r su #w< C & & < s   (NNNNN   C%uz2 3 3< ) )A%a(( ( ( ( ( ( ( ( ( ) ) C & &<!#((**---------S!! <%cjjll33 3 3 3 3 3 3 3%c&8&8&:&:;; ; ; ; ; ; ; ; ; ; << < zfree_symbols..(s$*G*Ga1>*G*G*G*G*G*Grw)r=rnext StopIterationrunion)ritr first_exprs rvrr s {||   C#YY || ): " (*G*G3*G*G*G HHs1A  A cPtdt|D S)z)Faster version of bool(free_symbols(val))c32K|]}|jp|jVdSr) is_number is_Booleanr$s rvr&z#has_free_symbols..-s+NNQAK/1<NNNNNNrw)allrrs rvrr+s*NN.:M:MNNNNN NNrwrcddlm}t|D]A}||D]3}|jr*t |t jt jfrdS4BdS)z2Faster version of bool(free_unbacked_symbols(val))r)iterargsTF)sympy.core.traversalr2r is_SymbolrRrS UNBACKED_INTUNBACKED_FLOAT)rr2r args rvrr0s------ A  8A;;  C} d')<="" ttt   5rwcNtdt|DS)z?Like free_symbols, but filtered to only report unbacked symbolsc3fK|],}t|tjtjf(|V-dSrrRrSr5r6rr s rvr&z(free_unbacked_symbols..AsQ !d/1DE F F rw)r=rrs rvfree_unbacked_symbolsr<=s8 a  rwunbacked_inputsc.t|}||z }|S)zUnbacked symbols that are not inputs to the graph. These are symbols that originated from data-dependent operations as opposed to mark_unbacked calls.)r<)rr=unbacked_symbolsnon_source_symbolss rv!_free_non_source_unbacked_symbolsrAHs# -Q//)O; rwsympy.Symbol | NonecLd|jvrt|jdtjrut|jdjjt jrF|jdks$t|jdjjr|jdjjSdS)a Check if a given FX node is a symbol binding node. A symbol binding node is one that has a SymInt value in its meta that contains a sympy Symbol expression, and is either a placeholder node or contains unbacked symbols. Args: node (torch.fx.Node): The FX node to check Returns: Optional[sympy.Symbol]: The sympy Symbol if the node is a symbol binding node, None otherwise rrN) rrjrpr"rqrorrrr<rs rvrrTs  ty' 6 6  ty',15< @ @  G} $ $$TYu%5%:%?@@ %y$)) 4rwgraphtorch.fx.Graph!dict[sympy.Symbol, torch.fx.Node]cRi}|jD]}t|x} ||vr|||<|S)a Find all nodes in an FX graph that bind sympy Symbols. This function scans through all nodes in the given FX graph and identifies nodes that bind sympy Symbols (typically placeholder nodes with SymInt values). When multiple nodes bind the same symbol, only the first occurrence is kept. Args: graph: The FX graph to search for symbol binding nodes Returns: A dictionary mapping from sympy Symbols to their binding FX nodes )nodesr)rDrrqr s rvfind_symbol_binding_fx_nodesrJnsD ,.A *400 0A =!1**AaD Hrw)frozenslotsc(eZdZUdZded<ded<dS)rar This class is used in multi-graph compilation contexts where we generate multiple specialized graphs and dispatch to the appropriate one at runtime. This allows us to optimize the trade-off between performance and generality by creating specialized versions for common patterns (e.g., x.shape[0] % 16 == 0) while maintaining a general fallback. r\sourcezCallable[[int], bool]check_fnNrrrrrrrwrvrrs6!   ######rwrceZdZd dZd dZdS) rrfrcdS)Nz#.cast_symbool_to_symint_guardless()rrs rv__str__zConvertIntKey.__str__s44rwbrrrac t|S)zGet the int value from bool) cast_symbool_to_symint_guardlessrrTs rvrzConvertIntKey.gets/222rwNr)rTrrrfra)rrrrSrrrwrvrrs<5555333333rwrc*eZdZUded<d dZd dZdS) CallMethodKeyrnamerfcd|jdS)N.z()rZrs rvrSzCallMethodKey.__str__s 49    rworc<t||jS)zCall the method on object)getattrrZrr^s rvrzCallMethodKey.gets$wq$)$$&&&rwNrr^rrfrrrrrrSrrrwrvrYrYsG III!!!!''''''rwrYc*eZdZUded<d dZd dZdS) InnerTensorKeyr inner_namerfcd|jSNr\)rfrs rvrSzInnerTensorKey.__str__s$4?$$$rwr^rc,t||jS)zGet the inner tensor attribute)r`rfras rvrzInnerTensorKey.getsq$/***rwNrrbrcrrwrvreresGOOO%%%%++++++rwrec*eZdZUded<d dZd dZd S) DivideByKeyradivisorrfrcd|jdS)Nz.__floordiv__()rlrs rvrSzDivideByKey.__str__s/ ////rwr^rtc||jzS)zDivide object by divisorroras rvrzDivideByKey.getsDL  rwNr)r^rtrfrtrcrrwrvrkrksJ0000!!!!!!rwrkFrr;pytree.KeyPathreal object | Nonependingset[sympy.Symbol] | Nonesimplify"dict[sympy.Symbol, pytree.KeyPath]c . tjt|dfd }|t}iddfd }t |t t frhtt|D]I} ||tj |fz|||ndJnMt|r| \} } | D]B} t|| }  | t| fzCt jr/t |t jjjr ||nt |t jrNt-|st/|r0t1|}  | n+t |t jrft-|sWt/|sHddlm}t ||st7dt9||||jnt |t jt jfrt ||x}t@j!ru||vrq|<rS|Qt |tDtFfst7dt9|$|||%|nt |t jrt ||x}t@j&rt|j'dkrt |j'dx}t@j(t@j!fr[t |j'dx}t@j!r3||v||vz r)t ||vr|n|x}t@j(s r|j)vrdfd }||vr|n|}r)t |t@j(rtE|n ||}tU|fz|<|t |tDst7dt9|t |t@j(r|tE|zntW||}r$|||%|nt |t j,rt ||x}t@j-rt |j.t@j!r|j/dkr|j.|vrtafz|j.<|Zt9|tburt7dt9|r#$|tE||%|j.S)a2 Recursively traverses a structure to find unbacked symbols and their access paths. This function walks through tensors, lists, tuples, and symbolic values to locate unbacked symbols that are in the pending set, and returns a mapping from those symbols to their access paths in the structure. Args: a: The object to traverse (tensor, list, tuple, SymInt, etc.) path: The current path in the object tree real: Optional real tensor corresponding to the fake tensor being traversed shape_env: Optional ShapeEnv to register unbacked values with pending: Set of unbacked symbols to look for (will be modified in-place) simplify: Whether to use simplified expressions Returns: A dictionary mapping unbacked symbols to their access paths rlrtrvr SymInt | SymFloat | SymBoolrfrc8r |jjS|jjSr)rqror)r rvs rvroz._free_unbacked_symbols_with_path..exprs!  6; v|rwNrdrK real_tensortorch.Tensor | Nonerc |tdfz||nd|jtjtjtjtjfvrZ| tdfz|| nd| tdfz|| nddS)Nrrrrr) updaterrYlayoutrp sparse_csr sparse_csc sparse_bsr sparse_bscrr)rdr|gor;rIs rv match_tensorz6_free_unbacked_symbols_with_path..match_tensorsh  B f--//+6+B[%%'''       8            HHHHJJM(33551<1H++---d     B  "" &677994?4KK..000QU         rwrrr]zExpected FakeTensor, got zExpected int or float, got rr sympy.Symbolr"c|tj|j|dgdS)NrrurN)create_symintnodertbacked_var_to_valvar_to_sourcesr)r rls rv _symint_wrapz6_free_unbacked_symbols_with_path.._symint_wrapWsS..4Q788 /33Av>>qA/ rwrirq)r rzrfrr)rdrKr|r}rfr)r rrfr")2rpartial _free_unbacked_symbols_with_pathrArjrrVrangerrr SequenceKeyr>__tensor_flatten__r`rerp distributed is_availabletensorDTensorrZr$r%r#rr^rmrsr|r"r!rrrtrb"set_real_tensor_prop_unbacked_valsremoverrrrrkrAr rrrrrr)rdr;rrrlrtrvrorrattrs_attrsubunwrapped_tensorr^r rrcoeffrunbackedrlrrrIs ` ` ` @@rvrrs4  (    B%% A         >!eT]##ws1vv  A HHaDF.q1133$($4a$      'q ) )l''))q > >D!T""C HHRRT^D%9%9$;;<< = = = =   ) ) + +  u '/1 1   LOOO Au| $ $``4Q77`)++ $d++,,,,1el##[ ##[&a(([ =<<<<<!Z(( H !FT!WW!F!FGG G Q &&&&1u|U^455Q DDGG|qU\ 2 2Q LL!  B)dS%L11 Q$%O4::%O%OPPP  8 8D A A Aq 1el##? DDGG|qUY / /? KK1   afQi's%-)F G G  afQi's 6 6 Wn 0  s''9'9sBuEM R R  444      ..33c %'u}== %CJJJe$$ k'2244(  dC(( H$%F$t**%F%FGGGeU]33+E ""dE**   L<Q0R0ROAv M$q''MMDGGMMNNNrwcdt|dkr|S|D]}tj||}|S)zA or, but for symbolic expressions, without bool casting. r)rror_rs rvrrsA 6{{a  LA   Hrw0SymBool | SymInt | SymFloat | int | bool | floatbool | int | floatc(t|ttfrt|St|tt frt |St|ttfrt|Std|)a Guard a scalar value, which can be a symbolic or concrete boolean, integer, or float. This function dispatches to the appropriate guard function based on the type of the input. Args: a: A symbolic or concrete scalar value (bool, int, or float) Returns: The concrete value after guarding Raises: AssertionError: If the input is not a recognized scalar type zunrecognized scalar ) rjr rrrr"rtrr!rbrrmr\s rvrrs"!gt_%%9!}} A} % %9|| A%( ) )91~~7A77888rwr"cHt|trt|jtrlt|jjt jrJ|jj@|jj|jjrt|dSdSdSdSdSdS)ax Don't use this directly; use torch._check_is_size instead. This is a softer version of _constrain_range_for_size (with min=0, max=Inf). Instead of forcibly constraining a variable (and erroring if we failed to constrain it), it will simply advise us that a size is constrained in some way. We will always defer a runtime assert for this constraint if we cannot prove it at compile-time, but we we only *sometimes* learn useful extra information at compile-time with this information. This is in contrast to constrain_range_for_size, where if you don't call that on a fresh unbacked symint, chances are we will choke. TODO: Make Dynamo handle this appropriately if this is seen in Dynamo-ed code. Right now this is only really used in code with AOTAutograd trace through, so it is not a big problem that this isn't supported, but in principle all of this code should be Dynamo'able too. TODO: I didn't support min/max because I didn't have a use case where this actually helped. In principle we can support it, it just makes the implementation below more complicated. N) rjr"rqr:rorrrlis_unbacked_symint_constrain_range_for_sizer\s rv_advise_is_sizersD 1f% qvw ' '% qv{EL 1 1% F  ( F  / / < < ) "!$$$$$%%%%%% ) ( ( (rw upper_boundct|trt|jtrt|jjt jrz|jjp|jj|jjrIt|tr6|jj |jj|dSdSdSdSdSdSdSr) rjr"rqr:rorrrlrrt_constrain_is_bounded)rdrs rv_advise_is_boundedrs1fI qvw ' 'I qv{EL 1 1I F  ( F  / / < < ) {C ( ( ) ..qv{KHHHHHIIIIII ) ( ( ( ( (rwminmaxcft|ttfrtdt|tst dt|jjtj st d||jj |jj||dS)z= This function is NOT INTENDED to be used by itself. z$Constraining SymFloat/SymBool is nyiz#can only constrain range for SymIntzconstraining non-Symbols NYI: N) rjr!r rr"rmrqrorrrlrrdrrs rvrrs!h())A?@@@ a DBCCC afk5< 0 0CAaAABBBF..qv{CEEEEErw)rc 6|t }|t}||krtd|d|t|tr*||cxkr|ksntd|d|d|ddS|jj|jj||dS)a Applies a constraint that the passed in SymInt must lie between min-max inclusive-inclusive, WITHOUT introducing a guard on the SymInt (meaning that it can be used on unbacked SymInts). If min/max are None, we assume that the dimension is unbounded in that direction. Repeated application of constrain_range intersects the ranges. This is a fairly low level API that doesn't have a lot of safety guarantees (TODO: provide higher level APIs). Currently, we use this API in the following circumstance: when we allocate an unbacked SymInt, denoting an integer quantity which is data dependent, we ordinarily do not know anything about what values it may take. This means that any sort of guard on it will immediately fail. However, in many cases, we know something about the unbacked SymInt: for example, we know that nonzero(x).size(0) must be >= 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. N\Maximum value to constrain_as_size can't be less than the specified min value, received min= and max=Invalid value for range [:])rJrrjrtrqrl_constrain_rangerors rvconstrain_ranger s2 {g { Syy 0 0 0*- 0 0   !SqCIaIISII3IIIJJ JF%%afk3<<<<g|]}|jdk |jdS)rr)rrrrs rvrz'fx_placeholder_vals..s* K K KaQT]5J5JAF5M5J5J5JrwrDrHrs rvfx_placeholder_valsrs K K28> K K KKrw list[str]c.d|jjDS)Nc2g|]}|jdk |jS)r)rrrs rvrz*fx_placeholder_targets..s& F F F 0E0EAH0E0E0Erwrrs rvfx_placeholder_targetsr s F Fbhn F F FFrw ignore_staticrZr c|jtd|jt|||S)Ngm.shape_env must not be Noner )rlrmevaluate_guards_for_argsr)rr rs rv eval_guardsrsK |<=== < 0 0B # 1  rwdict[sympy.Symbol, int]c~|jtd|jt||S)Nr)rlrm bind_symbolsr)rrs rvrrs: |<=== < $ $%8%<%> I13D 4::f--..13DMM$4G4G1H1H 4::f--..  I IrwrNr(cX||jvr ||j|S|Sr)r7r<r*s rvr<zEqualityConstraint._findds- T] " "::dmF344 4Mrwroot1root2c*||kr ||j|<dSdSr)r7)rrDrEs rvr;zEqualityConstraint._unionks$ E>>#(DM%  >rwsrcrc||}||jvr |j|Stj|jSr)r<r8rrrZ)rrGs rvr=zEqualityConstraint._rewriteps@jjoo $*  :c? "<)) )rwr>r?rrc||x}|jvp;||x}|jvp||kp|||dS)Nc|Srrrs rvr|z-EqualityConstraint.is_equal..s1rw)r<r5 is_derived)rr>r?src1src2s rvis_equalzEqualityConstraint.is_equal|snZZ(( (TT-A A > 7+++0DD >t| >w== rw symbol_srcrA"Callable[[sympy.Expr], sympy.Expr]cl|||||kSr)r=)rrGrOrAs rvrKzEqualityConstraint.is_deriveds1}}S!!RR j(A(A%B%BBBrwNr)rNr(rfr()rDr(rEr(rfr)rGr(rfr)r>r(r?r(rfrr)rGr(rOr(rArPrfrr)rrrrrrr7r8rBr<r;r=rNrKrrwrvr1r1#s$.---('''    %*U%6%6%6H6666&+e&7&7&7E7777!I!I!I!IF)))) * * * *     CCCCCCrwr1symbolic_contextTypeGuard[SymbolicContext]ct|tstdt|turtddS)NzInvalid symbolic_context objectz%Illegal usage of symbolic_context ABCT)rjrrmrsrRs rv_assert_symbol_contextrVsM & 8 8@>??? 00DEEE 4rw/TypeGuard[sympy.Add | sympy.Mul | sympy.Symbol]cnt|tjtjfrvt |jdkrdS|j\}}t |rt|tjp(t|tjot |St|tjS)NrF) rjrrrrr_is_supported_equivalencerr)rorrs rvrYrYs $EI.// ty>>A  59S)#..Q:c5=3Q3Q sEM * * M/H/M/M  dEL ) ))rwrc|tjjjjtjjjjtjjjjS)zL Add functions that our sympy interpreter can't reify into FX nodes )hasrputils_sympy functionsToFloatrIr@rrs rv#_has_uninterpretable_sympy_functionr`sD 88 $, $/ $.  rwceZdZdZdS)raT Data structure specifying how we should create symbols in ``_create_symbolic_sizes_strides_storage_offset``; e.g., should they be static or dynamic. This is an abstract base class because we are probably going to add another version of this that says "use exactly these SymInts, don't allocate fresh symbols." NrrrwrvrrsrwrceZdZUdZded<dS)rzE Data structure specifying any constraints on a SymInt input DimConstraint constraintNrPrrwrvrrs*rwr_P1_T1ceZdZUdZded<dZded<dZded<dZded<dZd ed <dZ d ed <dZ d ed<dZ ded<ddZ dS)rz Create symbols in ``_create_symbolic_sizes_strides_storage_offset`` via a symbolic_context determination as given by ``DimDynamic`` and ``DimConstraint``. This will cause fresh symbols to be allocated zDimList[DimDynamic] dynamic_sizesNdynamic_strideszDimList[DimConstraint]constraint_sizesconstraint_stridesz%list[list[Callable[_P1, _T1]]] | None specialize_onSymbolicContext | Noneview_base_contextzdict[int, str | None] | None shape_idsz/dict[int, tuple[int | None, int | None]] | Noneunbacked_boundsrfrc<|j2t|dggt|jz|j.sJ   z. 0BJOT T      rwz@dynamic_strides must only contain INFER_STRIDE, DYNAMIC, or DUCK) rlrr:rrhrirrrjrkr0rmrs rvrBz&StatelessSymbolicContext.__post_init__sN   %   s4-...      '   !()C0B,C,CC     (   (4&3t7I3J3J*J     " *   *TFS9K5L5L,L     .      !R    rwr) rrrrrrirjrkrlrnrorprBrrwrvrrs '&&&+/O/////33333155555;?M????154444.2I2222GKOKKKKrwr)rKrLkw_onlycNeZdZUdZded<eeZded<dZded <dS) ra, Create symbols in ``_create_symbolic_sizes_strides_storage_offset`` via a symbolic_context determination as given by a cache of Source:Symbol. A cache hit will reuse a stored symbol, and a cache miss will write to this cache. This behaves like StatelessSymbolicContext, except the cache supersedes the other values - dynamic_sizes and constraint_sizes will not be read if we cache hit. It is the cache owner's responsibility to maintain the lifecycle of the cache with respect to different shape_envs, clearing, etc. r( tensor_sourcedefault_factoryz dict[int, dict[str, sympy.Expr]]#shape_env_to_source_to_symbol_cacheNztuple[int | None, ...] | Noneexcluded_sizes) rrrrrrrrxryrrwrvrr sr  MREMMM'59N888888rwrcDeZdZUdZeeZded<dZded<dS) ra The correct symbolic context for a given inner tensor of a traceable tensor subclass may differ from that of the outer symbolic context. This structure allows for this flexibility, with inner symbolic contexts mapped via attr -> symbolic context. rvzdict[str, SymbolicContext]inner_contextsTrrtrack_outer_size_strideN) rrrrrrr{rr|rrwrvrr5 sN 27t1L1L1LNLLLL$(((((((rwr)rLcBeZdZUdZded<ded<ded<dd ZddZdS)rzh Tracks the sources of all fake tensors we wrap in Dynamo. Used by shape guard computation. zFakeTensor | SymInt | SymFloatfaker(rNrmrRrfrtcBt|j|jjfSr)rr~rNrZrs rvrzTrackedFake.__hash__L sTY 01222rwrrrrct|tr(|j|juo|jj|jjkSdSNF)rjrr~rNrZrs rvrzTrackedFake.__eq__O s= e[ ) ) U9 *Tt{/?5.{ s HHHDAq!a%HHHrwrr) rrUrrrproductrrr)raddsrr7rrs rv _expandsumsr` s" D E :  KK     LL    i FIIHHI$5fch$G$GHHH Y F 3t99q=FSYY]%Es5zzA~ FFrwcd|jD}tdt|j|Drt|j|S|jrk|j\}}|jrY|jrR|dkrtj |dS|dkr0tj tj tj |z dz Sn|j rg}g}|jD]R}|jr4|jddkr#| tj |z =| |St|\}}t|\}}|s|r||z S|S)a A faster implementation of sympy's expand function for common cases. This function expands expressions like (a+b)^n or (a+b)*(c+d) into sums of products, but avoids the expensive checks and features of sympy's full expand implementation. It only recreates objects when necessary to avoid expensive operations. Args: expr: A sympy expression to expand Returns: The expanded expression c,g|]}t|Sr) _fast_expandrr7s rvrz _fast_expand.. s 777c S!!777rwc3$K|] \}}||uV dSrr)rr7new_args rvr&z_fast_expand.. s+ K K,#w3g  K K K K K KrwrF)deeprrS)ranyrrfuncis_Powrrrexpand_multinomialrr rrUr) ronew_argsbaseexpnumdenr7 num_changed den_changeds rvrr s*87TY777H K K#di2J2J K K KKK2IDIx0111 {I c > Rdk RQww/5AAAAquu7 5QQQQQ   " "9  Cz chqkR// 153;'''' 3&s++[&s++[  + 9  KrwrIct|dr= t|S#t$r td||cYSwxYw|S)a Expand the given symbolic expression by recursively rewriting product of sums into sum of products (with the product being either a multiplication or exponentiation). NOTE: using this on an intermediate expression may prevent simplification down the line, e.g., if we eagerly expand `(a + b)^2` into `a^2 + 2ab + b^2`, we won't be able to simplify `(a^2 + 2ab + b^2) / (a + b)` as easily. expandz"RecursionError in _fast_expand(%s))hasattrrRecursionErrorrr)rIs rv safe_expandr sgq( ?? "    KKmTTTtt&k(&;&;<.wrapper s  MMOO  555$$&&& $ 5  MMOO  //(S8D24222622 2rwch|jkr|j|g|Ri|Sr)rr)rrrrrs rvrz_lru_cache..wrapper sM 555$$&&& $ 5 8D24222622 2rw)rrrrrrrfr)rconfigvalidate_shape_env_version_keyrwrapsrr)rArrrrrs @@@rv _lru_cacher s "y!!"%%HM ,3    3 3 3 3 3 3 3   3 3&    3 3 3 3 3 3   3#.G!,G NrwcbeZdZUdZded<edZded<edZded <d S) RuntimeAsserta This is pretty similar to ShapeGuard but it also comes with a message, and is exclusively used for things that MUST be true (unlike guards, which can evaluate False, in which case you just choose not to use a particular specialization) rroF)rrrrXstackN)rrrrrrrrrrwrvrr sfu%   C    $u%000E000000rwrceZdZddZdS)SymExprPrinterro sympy.Floatrfrc:tt|Srrrbrros rv _print_FloatzSymExprPrinter._print_Float s5;;rwNrorrfr)rrrrrrwrvrr s(      rwrcxeZdZdZdfd Zdd ZddZejddZ ejddZ xZ S)_ShapeGuardPrintera] Abstract base class for printers that convert symbolic expressions to string representations. This class provides common functionality for printing symbolic expressions with special handling for symbols that represent tensor shapes, strides, etc. Subclasses implement specific formatting for different output languages. Args: symbol_to_source: Mapping from sympy symbols to their source objects source_ref: Function to convert a source to its string representation var_to_sources: Mapping from sympy symbols to their source objects (for error reporting) symbol_to_source#Mapping[sympy.Symbol, list[Source]] source_refCallable[[Source], str]rrfrcr||_||_||_tdSr)rrrrr)rrrrrs rvrz_ShapeGuardPrinter.__init__ s8 !1$, rwrorrc:tt|S)z>Convert a sympy Float to a Python float string representation.rrs rvrz_ShapeGuardPrinter._print_Float s5;;rwrc t|tjstdt ||j|x}r||dS|j|x}r||dSd d}t|d||jd ||jd ) an Convert a sympy Symbol to its source representation. This method looks up the symbol in symbol_to_source mapping and returns the string representation of its first source. If the symbol is not in symbol_to_source (which can happen when symbols appear in guard expressions through simplification or substitution), it falls back to var_to_sources. Args: expr: The sympy Symbol to convert Returns: String representation of the symbol's source Raises: AssertionError: If the symbol is not found in either mapping Expected sympy.Symbol, got rrGrrfrcXtd|DS)Nc.i|]\}}|d|DS)cg|] }|j Srr]r;s rvrzU_ShapeGuardPrinter._print_Symbol..repr_sources...& s 9 9 9A 9 9 9rwr)rsymbolsourcess rvrzJ_ShapeGuardPrinter._print_Symbol..repr_sources..% s=+FG 9 9 9 9 9rw)rr)rGs rv repr_sourcesz6_ShapeGuardPrinter._print_Symbol..repr_sources# s8/2yy{{rw not in  or z\. This could be due to the issue described in https://github.com/pytorch/pytorch/pull/90665N)rGrrfr) rjrrrmrsrr print_sourcer RuntimeError)rrorNrs rv _print_Symbolz _ShapeGuardPrinter._print_Symbol s$$ -- M !KtDzz!K!KLL L*..t44 46 $$VAY// /*..t44 4V $$VAY// /    WWd.C!D!DWW< 344WWW rwrNr(cdS)z Convert a source object to its string representation. Args: source: The source object to convert Returns: String representation of the source Nrr*s rvrz_ShapeGuardPrinter.print_source1  rwrcdS)z Convert a sympy expression to its string representation. Args: expr: The sympy expression to convert Returns: String representation of the expression Nrrs rvdoprintz_ShapeGuardPrinter.doprint> rrw)rrrrrrrfrrrorrfrr,rorrfr) rrrrrrrabcabstractmethodrrrrs@rvrr s            ((((T                  rwrc4eZdZdZdfd Zdd Zdd ZxZS)ShapeGuardPythonPrintera Python printer for shape guards that extends the base ShapeGuardPrinter. This class provides functionality to print symbolic expressions as Python code, with caching to improve performance when printing the same expressions multiple times. It handles printing of sources and expressions according to Python syntax. Args: *args: Arguments passed to the parent classes. rrrfrcBtj|i|_dSr)rr _print_cacherrrs rvrz ShapeGuardPythonPrinter.__init__X s%$35rwrNr(rc,||S)z Convert a source object to its string representation using the source_ref function. Args: source: The source object to convert Returns: String representation of the source )rr*s rvrz$ShapeGuardPythonPrinter.print_source\ sv&&&rwrorc|j|d}||Stj||}||j|<|S)a Convert a sympy expression to its Python string representation with caching. This method first checks if the expression is already in the cache. If found, it returns the cached result; otherwise, it delegates to PythonPrinter's doprint method and caches the result. Args: expr: The sympy expression to convert Returns: String representation of the expression in Python syntax N)r rrLr)rrorress rvrzShapeGuardPythonPrinter.doprinth sJ##D$// ?J'd33C&)D d #Jrwrrrfrr,r)rrrrrrrrrs@rvr r L so  666666 ' ' ' 'rwr z`torch.fx.experimental.symbolic_shapes.ShapeGuardPrinter` is deprecated, please use `torch.fx.experimental.symbolic_shapes.ShapeGuardPythonPrinter` instead.ceZdZdS)ShapeGuardPrinterNrrrwrvrr s  Drwrc0eZdZd fd Zdd Zdd ZxZS)_ShapeGuardCppPrinterrrrfrcht|_i|_tj|dSr)rA all_symbolssource_to_symbolrrr s rvrz_ShapeGuardCppPrinter.__init__ s1%(UU<>$rwrNr(rc&||jvr|j|jS|j}tjdd|}|}d}||jvr|d|}|dz }||jvt j||j|<|j||S)Nz[^0-9a-zA-Z_]+rrr)rrZrerrrrr)rrN source_name mangled_nameold_mangled_namecounts rvrz"_ShapeGuardCppPrinter.print_source s T* * *(05 5k v.[AA 'd....8888L QJEd...). \(B(Bf% \***rwrorc,tj||Sr)rKrrs rvrz_ShapeGuardCppPrinter.doprint s!$---rwrr,r)rrrrrrrrs@rvrr se         ........rwrceZdZUded<dS)_ShapeGuardsHelperrexprsNr!rrwrvr!r! srwr!ceZdZUded<dS)_CppShapeGuardsHelperzdict[Source, sympy.Symbol]rNr!rrwrvr$r$ s000000rwr$c eZdZdfd ZxZS)LoggingShapeGuardPrinterrrrfrcPt|d|dS)Nc|jSrr]rs rvr|z3LoggingShapeGuardPrinter.__init__.. s16rw)rr)rrrs rvrz!LoggingShapeGuardPrinter.__init__ s) )9)9>JJJJJrw)rrrfr)rrrrrrs@rvr&r& sGKKKKKKKKKKrwr&c,eZdZdZd fd Zdd ZxZS)DynamicDimConstraintPrinterz Printer for dynamic dim constraints. - Instead of symbol s_k it prints its source t.size()[i] - Instead of Eq(_, _), Mod(_, _), etc. it prints _ == _, _ % _, etc. We use this to suggest code for specifying dynamic dim constraints. r dict[sympy.Symbol, list[Source]]source_name_to_debug_nameMapping[str, str]rfrcdt||_||_dSr)rrrr-)rrr-rs rvrz$DynamicDimConstraintPrinter.__init__ s1  0)B&&&rwrorrct|tjstdt ||j|std|d|j|djS)NrzUnknown symbol z created by constraints solverr)rjrrrmrsrrrZrs rvrz)DynamicDimConstraintPrinter._print_Symbol s~$ -- M !KtDzz!K!KLL L$((.. Y !W4!W!W!WXX X$T*1-22rw)rr,r-r.rfrrrrrrrrrrs@rvr+r+ saCCCCCC33333333rwr+ceZdZdZd9d Zd:dZd;dZddZ d?dZ d;dZ d;dZ e d@d!ZdAd#ZdBd'ZdCd)ZdDd.ZdEd7Zd8S)FDimConstraintsz Custom solver for a system of constraints on symbolic dimensions. Solutions are "static" values or simplified "dynamic" constraints. rr, var_to_val$Mapping[sympy.Symbol, sympy.Integer]marked_dynamicset[sympy.Symbol]r-r.rfrctt|_t|_i|_||_tt|_t|_g|_t|_ t|_ t|||_ g|_ ||_tt t"t$h|_|dSr)r rA_univariate_inequalities_symbols_with_equalities_substitutions _var_to_val _congruences_multivariate_inequalities_symbolic_equivalences_static_results_dynamic_resultsr+_dcp_inconsistencies_marked_dynamicr?rGrHrB_supported_sympy_functions_enumerate_sympy_functions)rrr4r6r-s rvrzDimConstraints.__init__ s    % AUU'HJ# *-*-%%0 7   ,. .     @ ' '')))))rwr rrorcddfd }dfd }|tr|t|}|tr|t|}|tr|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). rrrfc0|\}}||}}|j|jz}||z |z}|dkr j||Srrewrite_with_congruencesrr<r=rrrrl mod_reduced congruencer rs rv mod_handlerz.mod_handler s0!MD'--a66--a99D--(899G.floor_div_handler; s!MD'--a66--a99D--(899Grr'iterr=rJrr:r9) rro orig_expr orig_reducedrr old_n_congruencesnew_n_congruencesreduceds rvrzDimConstraints.addr s 5:  4  ))$*:;; 5; & &  ! ( (I)H)H)H I I I  58UXuy1     1 1$ 7 7 5(   KTKK  |  q  + / / 5 5 5 5T,''((A #D$5a$8 9 9 00D99D #D$5a$8 9 9 uz!!(,===mmD$455G%+%%%,,''Y'''$)) 5-11!444  )! , 0 0 6 6 6urwrNr(rc|jr&|j|jd|dS|j||fdS)zAdd an equality constraintrN)r.r@rrZr?rU)rrNros rv add_equalityzDimConstraints.add_equality s\ > ?  $ $ %?%?%?%? @ @ @ @ @  ' . .~ > > > > >rw#dict[sympy.Symbol, set[sympy.Expr]]c i}|jD]d\}}g}t}|D]}|j\}}t jdd} t j||| zz |g\} } || krytjj | | \} } t| tj r7t| tj r| | z} | | | f| ||rnt jjj|\} } || z | zh||<|| t jddz| zi||fd|D_|||<f|S)Nreduce_congruences_tmpTr)symbolstmpc3FK|]}tj||VdSr)rchecksol)rrM substitutions rvr&z5DimConstraints._reduce_congruences.. sI.." >*lCC.......rw)r=rrArrr solve_linearpolys polytoolsdivrjrrUrntheorymodularsolve_congruencer)rreduced_congruencesr  congruencesremainder_modulus_pairscongruences_to_checkrMrrlrkrsolutionmodulus remainderrns @rv_reduce_congruencesz"DimConstraints._reduce_congruences sCE"/5577* >* >NA{QS ##&55 ) 5 5 * gl#;TJJJ#(#5dWs]6JUVTW#X#X#X ;;).)>)B)B8S)Q)Q&GY!'5=99!j!5=??!%.$7 /66 77KLLL %((4444' >%*]%:%K,&" 7,-y=G*C)D#A&weT!B!B!BBYN  $A&--....&:... *>#A&&""rwc|jrEd|j}|jtd|dS)N z*The following inconsistencies were found: )rCr@rr)rrs rv_raise_inconsistenciesz%DimConstraints._raise_inconsistencies sZ   R))D122C  ! ' ' ) ) )P3PPQQ Q R Rrwc  jrj}j|}tjj||}t|tj rNtd|j D|}t|tj std|d||j \}}||krtd|d|jjj|djd||j|<j}t+_|D]7}||j|i8j}|D]\}} | D]x} |jvs#t j| |j|isI| r3| j \} } dt7jjjj|djjj|djz} t j| d }dd lm }|| gjj|<tCt j | | |z|}|td | d| d|d|j"j#t j ||dzjD]f\}} tjj||}t|tj$r-ttKfd|j D}t|tj r=|j D]4}j"j#|5n2j"j#|#tLtf$rWtN(dd |D]4}j"j#|5YdwxYwj)}g_)|D]3\}}*||j4j)D]A\}}j"|jdj#|Bd S)zGSolve the system of constraint equations to find simplified constraintsc3NK|] }t|tj|V!dSr)rjrrrs rvr&z'DimConstraints.solve.. s3OOSZUX5N5NOSOOOOOOrwz$Expected an equality constraint for z, got zExpected a constraint on z instead of on rrrTri)ConstantSourceNzFailed to solve  = z *  for rc3PK|] }|j|V!dSr)rr<)rr7rs rvr&z'DimConstraints.solve..+ sL #"||D,<==rwzFailed to reduce inequalities)exc_info)+rr:popr9rsolvers inequalitiesreduce_inequalitiesrjrr'rrrmr@rrBrrZr;r>rArr}rrm_is_supported_congruencerr-rrtorch._dynamo.sourcerrOrArrr^NotImplementedErrorrrr?re)rr r"rzrrmultivariate_inequalitiesrorvrwrMrrltmp_namerkrrIr7expr2symbolic_equivalencesrNexpr3s` rvsolvezDimConstraints.solve s ##%%%+ *-1133A155a88E}1EEeQOOH(EI.. OOHMOOO"(EH55(RqRRRR#-KFC{{$JJJ&JJ  $ $9-a038CCcCC   &)D  ")-(G %.1eeD +1 E E4+>q+A'BCCDDDD  ' ' ) ) )=+ *D#668817799 X XNA{) X X D///u~D$7$: ;88/44Z@@X(2 g#& I?CC $ :1 =a @ E $ :1 =a @ E**$ $l8TBBBGGGGGG;I>(;S;S:T 237%ehtWs]&C&CQGG9"0 U4 U UG U U U URS U U##-11$)2C2CEHQPQRSPTDUDU2V2VWWW- X25;;== H HHAu H =5II%QRSSh11#'/}  Hh 22K'}JJ-11$)2C2CC2H2HIIIIJ)--di.?.?.I.IJJJ'8 H H H ;d KKK"HHE)--di.?.?.F.FGGGGHH H !% ;&(#2 K KMFE   fennT5H&I&I J J J J"8 V VMFE  ! % %&T&T$):K:KE:R:R&T&T U U U U V VsC5Q99A$S! S!rMc|j\}}t|tjrs|j\}}t|tjot|tjp3t|tjot|tj}nt|tj}|ot|tj}|Sr)rrjrrrr)rrMrrlrrrs rvrz'DimConstraints._is_supported_congruenceE s" g dEI & & 2yHC3 --P*S%-2P2PTS%-00RZU\5R5R DdEL11D: 7EM:: rwdict[str, sympy.Expr]c^dfd fdjDS)zGReturns a dictionary of the names of symbols to their specialized valuerGr(rfrc\|j}jjrjj|d|S|S)Nr)rZrBr-)rGrZrs rv debug_namez9DimConstraints.forced_specializations..debug_nameY s:8Dy2 )=dCNNNNN rwcli|]0\}}|jvjj|d|1Sr)rDrBr)rr rrrs rvrz9DimConstraints.forced_specializations..` sP   3D((( Jty1!4Q7 8 8#(((rw)rGr(rfr)r;r)rrs`@rvforced_specializationsz%DimConstraints.forced_specializationsV sa           -3355    rwrXr2TypeGuard[torch.export.dynamic_shapes._DerivedDim]cJt|tjjjSr)rjrpr$dynamic_shapes _DerivedDimrrXs rv_is_derived_dimzDimConstraints._is_derived_dimf s#u|:FGGGrw*TypeGuard[torch.export.dynamic_shapes.Dim]ct|tjjjo$t|tjjj Sr)rjrpr$rDimrrs rv_is_dimzDimConstraints._is_dimk sB#u|:>?? ,8I I E  rwresultsdict[str, dict[str, Any]] name_to_dimdict[str, Any]c < ddlm}dfd }i}t|D]v\}}d |vrkt |d t jrJtt|d j }t||vr||t|<t j j |d |\} } |d d } tj| | z | z } |d t"} tj| | z | z }| |d|t|<|t|| ||t|<|d d|d dx|D]}|D]}d |vrt |d t jrwttt|d j x}|kr=|t|d }|d ||i}||d <t-}|D]\}}||vr ||rd |vsd |vr||Cd |vrzt |d t jrZtt|d j }|t3d|t|||}i}|D]K}d}||vrD||}d |vsd |vst |d t6r||||s|||<d}|r|D]\}}||vr ||}|jjdkr|jj|krd |vsd |vrt j|}tt|j }tAt j!||d |dtAt j!||d |dd}||||s|||<nMt|"D])}||vr#||s||vr||=*|$|dS)a Here we resolve 2 concerns with derived dims suggested fixes: 1) newly introduced roots, and 2) root swapping. 1) Newly introduced roots appear with modulo guards, e.g. Mod(dx, 2) = 0 suggests dx is a derived dim equal to 2 * _dx, introducing a new root _dx. Currently the final suggested fixes handle this correctly, but we can get intermediate results that look like {"dy": {"eq": "dx + 1"}, "dx": {"eq": "2 * _dx + 1, "min": 3, "max": 15}} and this routine prettifies this by unifying to a single root, and making each suggestion either a derived dim or min/max range, not both. 2) With suggested fixes for derived dims, roots can be swapped, e.g. dx, dx - 1 -> dy + 1, dy. Here we don't want to print out the attached name, since this leads to messages like "dx - 1 = Dim("dx - 1", ...)". Instead we evaluate the new root value, and remove results for its derivations. First we find all the original roots (specified in dynamic_shapes), that are found in the values of results (i.e. used for computing suggesting fix values). These original roots (suppose `dx`) are either specialized, unchanged, refined, or swapped (expressed as a derived dim). If any of the first 3 cases happen, we suggest `dx`'s value in results, and remove suggestions for derivations of `dx`, assuming the derived relation is valid. If swapped, we find the new root, and use the fix to evaluate `dx`'s new value, and then do the same with `dx`'s derivations. Assuming the originally specified derived relations are correct is valid, because: 1) if the relations are plain wrong (e.g. input shape = (6, 4) with spec (dx, dx - 1)) produce_guards() will catch this and crash before hand. 2) if the relations are numerically correct but do not match the emitted guard, for example: def forward(self, x, y): return x.reshape([-1]) + y # guard: s0 * 2 = s1 inputs = (torch.randn(6, 2), torch.randn(12)) dx = Dim("dx", min=2, max=32) dynamic_shapes={"x": (dx, 2), "y": (dx + 6, )} # this matches values but not op then this leads to 2 linear equations, and a) produce_guards() is able to solve for the unique solution of dx = 6 and specialize, and b) the export constraint solver will raise an issue due to range constraints (a unique solution means not all values in a range satisfy a guard) and also force specializations. r)rcMapping[str, int]rXrrfrrc|ood|vpd|vog|jdkr|dddkp|j|ddko#|j|dtkS)Nrrr)rrrrrJ)rrXrs rv_check_same_rangezDDimConstraints._process_derived_dim_roots.._check_same_range s S!!4aZ-5A:4Wq[9QUU5!__%9XcguVW>X4 GquuUF333  rwrrrr)rrNzroot must not be NoneTFrr)rrrXrrfrr)%torch.export.dynamic_shapesrrVrrjrrr'r^rrrprqrrrrceilrJfloorrrsubsrArrrmrUrtrrr@rrOrrrr)rrrrrintroduced_rootsrrr@r{r|c_minmin_c_maxmax_old_rootr new_root_exprrmodified_rootsmodified_root_valuesmroot swapped_rootrXror rs` rv_process_derived_dim_rootsz)DimConstraints._process_derived_dim_rootsp sp\ 433333      *,.)) ' 'DAqqyyZ$<)B)B1T7D)Q)Q&GYEE%OOE9ei&77%BCCDEE%00E:uy'8G&CDDD15d)C)CGCII&-0ST$-O-O-OKD *EE%&&&EE%&&&)//11 ' 'H^^%% ' 'AII"1T7EJ77d4$0D+E+E&F&FFFGG8SS$+CMM$:4$@M w||V],CDDH&AdG ' $'55MMOO . .DAq ##||KN++ .!uzz""1%%%%z!D'5:>>D4!56677<()@AAA""3t99---(223CDD ;=#( &( &ELENQJJ%1**dGS22* -,;u-878,U3#(L &$MMOO&&DAq ++ %a.C .-??H-66!A::!#(=#3#3D $T$*;%<%< = =A'0$%1I1I1'M'Ma'P'0$%1I1I1'M'Ma'P&&F$5#4 & +E 2$$&?E 4U ; % gllnn%%  A ####KN33 qN7J7JAJ +,,,,,rworiginal_signatureinspect.Signaturer'dict[str, Any] | tuple[Any] | list[Any]constraint_violation_errorrdict[str, str]rc :ddlm}jjsdSd/d0fd t t |i}d1d }d2fd }||}jjD]} | } | | krtj d| \} } } | } | dkr| | krN| r|| | t| }| r$|| || t| | dkrtd| d|  tj| | d<#t"$rYwxYwfdt%dDd}rt)}D]r}|| dd}|r ||jjX||js|ddt%|dz }D]\} }|d| d |d!z }|g}g}fd"t%fd#D}|D]$\}}d|vrb|d}t9|tr||d|Bt=|r||d|l|d$d }|d%krd }|d&d }|$|"||d'|d(|d)|d*|||d'|d(|d*| ||d'|d+|d* ||d'|d,&|s|r |d-z }|d.||zz }|S)3z0Format a message for constraint violation errorsr)_get_dim_name_mappingrpFr rinverserrrfcjjD]3\}}|s|||n|||}4|Sr)rBr-rrQ)r rrrrs rv transformz2DimConstraints.prettify_results..transform6sV ;AACC H H1+2GAIIaOOO !QHrwNrcv|dkrdS|dkrdS|dkrdS|dkrdS|dkrtd||S)N<=>=<>==Expected op to be '==', got r)rs rvflipz-DimConstraints.prettify_results..flip?s_TzztTzztSyysSyysTzz$%HB%H%HIIIIrwrodigitrtrc|dkr ||d<dS|dkr|dz |d<dS|dkr ||d<dS|dkr|dz|d<dS|dkrtd |||d <dS) Nrrrrrrrrrrr)rorrrs rvrelation_with_digitz.relation_with_digitLsTzz', e$$$s',qy e$$$t', e$$$s',qy e$$$::()L)L)LMMM&+ d###rwz( == | <= | >= | < | > )rrrrc"i|] }|| Srr)rrrs rvrz3DimConstraints.prettify_results..rs1" " "  %a(" " " rwc8|ddS)Nrr)splitrs rvr|z1DimConstraints.prettify_results..vsaggennQ/rwrrz'Specializations unexpectedly required (, 9)! For more information, run with TORCH_LOGS="+dynamic". z% - solving the guards generated for z$ resulted in a specialized value of z. c"i|] }|| Srr)rrrs rvrz3DimConstraints.prettify_results..s/    wqz   rwc|dS)NT)rr)rrs rvr|z1DimConstraints.prettify_results..sii4888rwrrrz = Dim('z', min=z, max=rnz', max=z')z Suggested fixes:  F)r rrrrrfr)rrrfr)rorrrrrtrfr) rrrBr-r rr@r)rArrstripisdigitrtrmrr TypeErrorrrrArrr@rr@rrrjrUrYr)rrrrrrrrrr rleftrrightbuf debug_namesrrXrdimsrresults2rrrrrrs` ` @@rvprettify_resultszDimConstraints.prettify_results(s FEEEEEy2 2        5@4E4E  !N     , , , , , ,,+N;; %++D,ABB  A ! AAvv h'BAFFOD"eBTzzdemm}} ##D"c%jj9999 ##E4488SYY????::()T)T)TQR)T)TUUU*/-*>*>GDM$'' D" " " " &++--//" " "  ! o%%K+ 2 2!!''%.."34'',,2OOCH$56666OOCL1111 J$))F;DWDW:X:XJJJ C16688 o o3nqnnfinnnn ''===     8888   NN$$ 5 5DAqqyy$eS))4MMQ"2"25"2"23333.u554MMQ"2"25"2"2333uuUD))199DuuUD))#(8KK1 K Ka K K K KD K K KLLLL%KK1 ? ?a ? ? ? ? ?@@@@%KK1 ? ?a ? ? ? ? ?@@@@KK1 3 3a 3 3 34444  .6 . + +C 6;;tf}-- -C s=E E('E(N) rr,r4r5r6r7r-r.rfr)r rrorrfrrrorrfrrrorrfrr)rNr(rorrfr)rfrf)rMrrfrr)rfr)rXrrfr)rXrrfr)rrrrrfr) rrrrrrrrrfr)rrrrrrJrFrZrrer}rr classmethodrrrrrrrrwrvr3r3 sz ;*;*;*;*zQQQQf    <<<< 0000d????.#.#.#.#`RRRR `V`V`V`VD[     HHHH     v-v-v-v-pLLLLLLrwr3c.ttddS)Nignore_fresh_unbacked_symbolsFr`TLSrrwrv"_ignore_fresh_unbacked_symbols_tlsrs 37 ? ??rwc:t}|t_|Sr)rrr)rTprevs rv"_ignore_fresh_unbacked_symbols_setrs - / /D()C% KrwGenerator[None, None, None]c#xKtd} dVt|dS#t|wxYw)a Indicates that newly allocated unbacked SymInts are intentionally discarded. This is used by tracing-only metadata paths that do not own a ShapeEnv, but still create temporary fake tensors whose fresh symbols should not be bound into the surrounding graph. TNr)rs rv*_ignore_fresh_unbacked_symbols_tls_contextrsL .d 3 3D1 *400000*40000s(9cZeZdZUdZded<ded<ded<ded<ded<ded<ded <d S) ShapeEnvSettingsz Encapsulates all shape env settings that could potentially affect FakeTensor dispatch. Used when creating dispatch cache keys. rrallow_scalar_outputsallow_dynamic_output_shape_opsassume_static_by_defaultspecialize_zero_one duck_shape+prefer_deferred_runtime_asserts_over_guards trace_assertsNrPrrwrvrrsr ((((""""5555rwrc(eZdZUdZded<ded<dS)rzG Locations of the guards that triggered lower and upper bound. r'r(r)NrPrrwrvrrs.KKKKKKKKrwrrc#K| dV|dS#|wxYwr)_suppress_guards_enter_suppress_guards_exit)rls rv_suppress_guardsrsV $$&&&* ''))))) ''))))s 2AcbeZdZUdZded<eeZded<eeZded<dS) _FrameLocalResultN str | Nonelocrvrlocalsrrj) rrrrrrrr rjrrwrvrrs_C"U4888F8888#eD999G999999rwrc  eZdZUddddSd Zd d d d ddd d ddTdZedUdZedUdZedUdZedUdZ edUdZ edUdZ e dVd%Z dWd'ZdXd(ZdYd*Ze dZd+Zed[d0Zed\d4Zed]d5Zed^d8Ze d_d`d<Zedad=Zedbd@ZdUdAZedcdBZe dZdCZedddDZedddEZdedGZdfdJZ dgdMZ!dgdNZ"dddOZ#edhdUZ$didWZ%djdYZ&dkd[Z'e(dUd\Z)eddd]Z*eddd^Z+dld`Z,e dZdaZ-dmdcZ.ddddZ/dndjZ0 dodpdnZ1ddodqdtZ2dddudrdzZ3edddudsdZ4dtdZ5edddudZ6edddvdZ7edwdZ8e dodxdZ9dydZ: d_dzdZ;ed{dZ<edod|dZ=d}dZ>d~dZ?eddZ@eeAjBddfddZCeeAjBdd d dfddZDddZEeeFdeGddZHeFdeGddZIddZJddZKddZLdfdddd d dddd҄ZMdd dӜddՄZNdd؄ZOddڄZPdd܄ZQd dݜdd߄ZRddZSddZTddZUdddZV dddZWeX dddZYeZdddZ[ddZ\ddZ]ddZ^ doddZ_eXd d d dddddZ`eXddZaeXdddZbeXdddZceFdeGeZdd d dd ZdeZdddZeeZdddZf doddZgddddZh dod dddZiddZjddZkeXeddZleZddd Zm ddd!Zndd"ZoeXdd#Zpdd%Zqdd'Zr ddd+Zsdodd-Ztdd/Zudd1Zvdd4ZwdZxd:eyd5< ddd8ZzdUd9Z{dd<Z| dd d=dd@Z}eZded dAB doddDZ~ddFZ dd d=ddHZdddIZddJZeZded K doddLZdgdMZeZdNeddRZdS(rN)should_record_events tracked_fakesr rr list[Any] | Nonerrrfrc 2|jdi|d|d<ddlm}||_||n|jo tj |_|jo tj|_d|_ ||_ |jrtt|gng|_ i|_dS)NFr rtranslation_validation_enabled)rr)_inittorch.fx.experimental.validatorr_translation_validation_enabledr translation_validation_no_bisectr check_shape_env_recorded_eventscheck_recorded_events is_recordingr r9reventsfake_tensor_cache)rr r rrs rvrzShapeEnv.__init__ s  V*/%&RRRRRR/M/M/O/O,$/ ! 4@?? !  % P&*P " "*( ]8F 3 3 3 4 4  rwTF)rrrrr co_fieldsrrrrrrrrrrdict[str, str] | Nonerrc F| tj}t||||||||_g|_i|_t |_i|_i|_ i|_ i|_ i|_ i|_ t|_i|_i|_i|_i|_i|_i|_t |_g|_t |_i|_d|_d|_i|_d|_t<|_|jdd|_ d|_!d|_"d|_#tIj%|_&tIj%|_'|r|ni|_(g|_)g|_*|+|_,d|_-d|_.d|_/i|_0i|_1i|_2i|_3d|_4d|_5||_6t|_7ddl8m9} | |_:|j:rqddl8m;} | |_<tzj>?|_@|j@A|j@Bdi|_Ci|_Di|_Eg|_FdS)N)rrrrrrrr create_envFTr)TranslationValidator)Gruse_duck_shapersettingsrBaxiomsrA unique_idsrreal_tensor_prop_unbacked_valsrvar_to_range_slocr-rr=r= var_to_stackvar_to_hint_override source_to_var replacementsreplacements_slocsr divisibleexclusion_constraints size_like val_to_varunbacked_symfloat_counterunbacked_symint_counterdeferred_runtime_assertsnum_deferred_runtime_assertsrrrK_error_on_new_guardsruntime_asserts_frozendim_constraints collectionsrcountersymbol_guard_counterrrrr_prev_cache_keyr_replacements_version_counter_resimplify_floor_div_axioms fx_node_cacherunbacked_alloc_orderspecialization_stacks_equality_graph_unbacked_replacementsrspecializationsrrrr validatorrpr&GraphrDinserting_beforeoutput name_to_node_shape_id_to_unbacked_symbol_spec_symbol_to_compile_symbol_shape_spec_pending_assumptions) rrrrrrrrrrrs rvrzShapeEnv._initHsL  .J(!5+I%= 3!8c'     )+ 46 %(EEEGRT+ JLFH9;&@B9CCE >@!68=?<>DF*-%% FH"-0EELN)*&'($>  % -.)  l### $)!&+#6:%0%8%:%: @!KM"QUKO#*;E<<RRRRRR/M/M/O/O,  / = L L L L L L1133DN))DJ J ' ' (9(9$(?(? @ @ @;=D  DF)OQ+  ,,,rwc|jjSr)r rrs rvrzShapeEnv.allow_scalar_outputsis }11rwc|jjSr)r rrs rvrz'ShapeEnv.allow_dynamic_output_shape_opsms };;rwc|jjSr)r rrs rvrz!ShapeEnv.assume_static_by_defaultqs }55rwc|jjSr)r rrs rvrzShapeEnv.specialize_zero_oneus }00rwc|jjSr)r rrs rvrzShapeEnv.duck_shapeys }''rwc|jjSr)r rrs rvrz4ShapeEnv.prefer_deferred_runtime_asserts_over_guards}s }HHrwrNr(rO$Callable[[sympy.Symbol], sympy.Expr]rc #K|j}|j|}|tt||tdjj}t|| |}i}|D]}t|tj rot|j tjrPt|jtjr1|j |jvr#|j|j|j <|j||j <|j|d|_ dV|D]} |j| d|D]} |j| dd|_dS#|D]} |j| d|D]} |j| dd|_wxYw)a Temporarily add symbol-level axioms to the ShapeEnv. This is useful when you want to "fork" and have parallel universes of ShapeEnvs. For example, we use this when doing multi-graph compile so we can support various graphs with varying levels of specializations. This context manager allows for temporarily adding constraints to the shape environment based on a specialization function applied to a symbol associated with a source. Args: source: The source of the symbol to specialize check_fn: A function that takes a sympy Symbol and returns a sympy expression representing a constraint/specialization to be applied NTF)rZr'r"r:rtrqrrget_implicationsrvrjrrrrrrr(r!rrKr) rrNrOrZsymro new_axiomsadded_replacementsaxiomrs rvpatch_source_specializationz$ShapeEnv.patch_source_specializations"{ &xwsD#t<<==>>CI$// d0C0CDDEE  : :E5%(++ :uy%,77 :uy%-88 :IT%666/4y!%),05 "59- :&&&  EEE ) ) 4((((' / /!%%a....DKKK   ) ) 4((((' / /!%%a....DK    s 5FA G rc6d}d d}t||||dS) z(Compare another ShapeEnv for equivalence)r6rr%r;rDrArr rr rr-r8rr4r$r)r9r:_expr_sym_node_idr=r>r?rrvaluerrfc|dkr d|DS|dkrd|DS|dkr!t|S|dvrdS|S)NrBcg|] }|j Srrrrgs rvrz;ShapeEnv.check_equal..map_value..s...1...rwr0c.i|]\}}|d|DS)cg|] }|j Srrr)rras rvrzFShapeEnv.check_equal..map_value...s222BG222rwr)rr rass rvrz;ShapeEnv.check_equal..map_value..s-OOOvq#22c222OOOrwrE)r7rr)rrAr)rrYs rv map_valuez'ShapeEnv.check_equal..map_valuesh......222OOOOOO&&5::<<((( tLrwN)rrrYrrfr)r8)rrnon_state_variable_namesrbs rv check_equalzShapeEnv.check_equals<$  F    & $D%1I9UUUUUrwcV|jdSddlmdfd fd|jDS) Nr)rr~rrfct|jtjtjfr|jnt j|j}||j|jSr) rjr~rpr"r!r5 from_fakerNrR)r~ inner_fakers rvmaybe_transform_fakez>ShapeEnv._snapshot_tracked_fakes..maybe_transform_fakesXdi%,)GHH9 #-di88 ;z4;8MNN Nrwc&g|] }|Srr)rr~ris rvrz4ShapeEnv._snapshot_tracked_fakes..s%JJJt$$T**JJJrw)r~rrfr)r torch._dynamo.variables.builderr)rrris @@rv_snapshot_tracked_fakesz ShapeEnv._snapshot_tracked_fakessh   %4?????? O O O O O OKJJJt7IJJJJrwrtc0t|jdz S)Nr)rrrs rv_last_event_indexzShapeEnv._last_event_indexs4;!##rwc#HKd|_ dVd|_dS#d|_wxYwNTF)rrs rv _recordingzShapeEnv._recordings>  & EEE %D   D  % % % %s !orig_srrrc4|||ddS)Neliminate_unbacked)_set_replacement)rrrrs rvrzShapeEnv._eliminate_unbacked s! fe-ABBBBBrwrrint | float | torch.Tensorcvtd||tj||j|<dS)zUsed only when propagate_real_tensors; registers a value for an unbacked symbol, which can be used last resort to resolve hints.z*set_real_tensor_prop_unbacked_vals %s = %sN)rrrrr#)rrrs rvrz+ShapeEnv.set_real_tensor_prop_unbacked_valss8 =q!DDD16q1A1A+A...rwc0t|tjstd|t|tjstd|t |std|t |std||j|}|#t |rt|d||||d||j|<||||ddSdS)Nrz.Expected new_s to have free unbacked symbols: z/Expected orig_s to have free unbacked symbols: z -> rename_unbacked_torename_unbacked_to_dest) rjrrrmr<r(rrur)rrrrdests rvrzShapeEnv._rename_unbacked_tosS&%,// I !Gv!G!GHH H%.. H !Fu!F!FGG G$U++  HHH %V,,  J&JJ  $$V,,  $T** <$%:%:D%:%:;;; fe-ABBB*/'    ! !%/H I I I I I  rwrdrcdSrr)rrdrs rvrzShapeEnv._constrain_is_bounded2s  rwrrzrc|d}|t}||krtd|d||||||j|dS)Nrrr compiler_min compiler_max)rJrconstrain_symbol_ranger,rrrdrrs rvrz"ShapeEnv._constrain_range_for_size7s ;C ;C 994 #44.144  ##  $   1rwc *t|tjrD|t|cxkr|ks(nt dt|d|d|ddSt|tjr||||dSdS)Nrrrrr~)rjrrrtrVrrrs rvrzShapeEnv._constrain_rangeMs a ' ' 3q66((((S((((%&Ws1vv&W&W3&W&WQT&W&W&WXXX F a & &   ' '   (       rwr"rTct|tst|ts||krtd|d|dSt|jjt jstd|jj|urtdt j||j |jj<dSt|jjt jstd|jj|urtdt|ts(t j||j |jj<dS|jj|jjurtdt|jjt jstd| |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!) rrzconstraining non-Symbols NYIzb.node.shape_env must be selfza.node.shape_env must be selfz)a.node.shape_env must be b.node.shape_envN) rjr"rmrqrorrrlrr(r<)rrdrTnew_vars rvrzShapeEnv._constrain_unify_s!V$$ 9a(( B66()?Q)?)?A)?)?@@@6"!&+u|<<I()GHHH6#4//()HIII16q1A1A!!&+... afk5<88 E$%CDDDvt++$%DEEEa(( 916q1A1A!!&+...6#16+;;;()TUUU!!&+u|<<I()GHHH**QV[1118!!&+...rwctSr)rrs rvrz+ShapeEnv._ignore_fresh_unbacked_symbols_tlss1333rwc t|SrrrWs rvrz+ShapeEnv._ignore_fresh_unbacked_symbols_sets1!444rwc#`Kt5dVddddS#1swxYwYdS)za Indicates that the newly allocated unbacked SymInts are being discarded N)rrs rvrz&ShapeEnv.ignore_fresh_unbacked_symbolss 8 9 9   EEE                  s #''cd|_dS)zFreeze this ShapeEnv to stop accumulating guards A frozen ShapeEnv will ignore any further guards generated on it and only emit a warning which may lead to accuracy problems. TN)rKrs rvfreezezShapeEnv.freezes rwcd|_dS)a_Freeze this ShapeEnv to stop adding deferred runtime asserts. We will error if you try to install a new runtime assert when it is frozen. This would indicate a lowering violation, or perhaps something we know statically is already True but we are checking it again in a way that is not clearly dischargeable. TN)r3rs rvfreeze_runtime_assertszShapeEnv.freeze_runtime_assertss'+###rwrBc|jsdS|j}||jvrtj|d|j|<|j|S)NTri)rrZrrr)rrNsrcnames rv_create_symbol_for_sourcez"ShapeEnv._create_symbol_for_sourcesQ3 4+ . . .-2\'4-P-P-PD !' *$W--rwrrscN|jr|j||dSdSr)rrAadd_var)rrrss rv _add_z3varzShapeEnv._add_z3vars5  / 1 N " "64 0 0 0 0 0 1 1rwrorcL|jr|j|dSdSr)rrAadd_target_exprrs rv_add_target_exprzShapeEnv._add_target_exprs3  / 1 N * *4 0 0 0 0 0 1 1rwcL|jr|j|dSdSr)rrA add_assertionrs rv_add_assertionzShapeEnv._add_assertions3  / / N ( ( . . . . . / /rwcJ|jr|jdSdSr)rrAvalidaters rv_check_translation_validatez$ShapeEnv._check_translation_validates1  / & N # # % % % % % & &rwrCallable[..., object]rtuple[Any, ...]!tuple[torch.fx.Node | None, bool]c||f}d}|jr||jvrtd|Dr,td|Dst dd|fSd}td|Dst d|jd||j||x}|j|<||j|j <|j |d|fS) NFc3K|]}|duV dSrrrrds rvr&z4ShapeEnv._create_fx_call_function..s&++19++++++rwc3VK|]$}t|tjj V%dSr)rjrpr&rrs rvr&z4ShapeEnv._create_fx_call_function..s3JJz!UX];;;JJJJJJrwz4Cannot mix SymNodes with fx_node and without fx_nodeTc3K|]}|duV dSrrrs rvr&z4ShapeEnv._create_fx_call_function..s&33q}333333rwzmissing arg in FX graph (z): ) rr;rr0rmrrDrrErZr)rrrnode_keyfreshrqs rv_create_fx_call_functionz!ShapeEnv._create_fx_call_functions%:  / 0HDDV4V4V++d+++++ #JJTJJJJJ(NU{"E33d33333 Y$%W%W%WQU%W%WXXX26*2J2J2t2T2T TD4%h/+/D di (!%%h55u<.is-??C{3'''??????rwz0Expect size to be a plain tuple of ints but got rTensorPropertyr\)do_not_specialize_zero_onerRryc3K|]}|duV dSrrrrs rvr&z=ShapeEnv._produce_dyn_sizes_from_int_tuple..s&::aATM::::::rw)r0rmrrr\rVrhrjr create_symbolrSIZErrrjrrlr@rrrrrRrSr,rUr`rrr_record_exclusion_constraint)rrrNrRrrr\ dynamic_dimsconstraint_dimsrrrrRspecializationryrXevs rvrz*ShapeEnv._produce_dyn_sizes_from_int_tuplebs??;?????  P;PP  NMMMMMMM N/000'5 *;!# ,,  FAs$$""1c**$$V^-@!DDQ"+1+G!1 %C+-EFF $2 '7&DQ&GN(,,&009LaPP*, (sEL11 (#3 22 ( ""3''' KK    !!13CTJJ+  CN##s**::>:::::+3ZZ C C#A&N"47EL99#."6B7755d1grBBB rwrUexrKrmDtuple[tuple[IntLikeType, ...], tuple[IntLikeType, ...], IntLikeType]ct|dd}|Y|j|urP||||||S||||dg|z||S)zCreate symbolic sizes/strides/offset for a tensor. If the tensor has symbolic sizes from a different ShapeEnv, delegates to transfer_symbols_from_foreign_shape_env. fake_modeNrUF)r`rl'transfer_symbols_from_foreign_shape_envrrr-_create_symbolic_sizes_strides_storage_offsetrX)rrrNrRrs rv,create_symbolic_sizes_strides_storage_offsetz5ShapeEnv.create_symbolic_sizes_strides_storage_offsets B T22  Y%8%D%D??  !!##!1 @ AA GGII IIKK      Gbffhh  - B   rwrRrrrWrrac  #$dd#dd$|=#fd |D}tjgt|z}t|| }n|j}|i}t |D]a\} } || tjurHt| r9| jj } | +| j | jj } | | || <bd dl } d d lm}m}t#$fd |D}t#$fd|D}$|}t%d|D}|s-||||dgt|z|||Si}g}t |D]\} }t|r|jj }||}|jt-|z rn||| |||j| || t5|dr |j| nd|}|||<|||||| j|g}|D]}t|r||jj |}|jt-|z r|jj }|||| j|t|rg|jj |}|jt-|z r|jj }n| j|}g}t |D]\} }|| }|||||||j| tA|dtBj"r&|r$| |vr || |j |djj <g}t |D]H\} } || }!||| |!|||j#| I||||||j$}"t#|t#||"fS)auTransfer symbolic sizes/strides/offset from a foreign ShapeEnv into this one. If symbolic_context is None, each dimension is auto-classified as STATIC, DUCK, or UNBACKED based on whether the foreign symbol has a guarding hint. If symbolic_context is provided (e.g. from _automatic_dynamic), its classification is used instead. For unbacked dims, strides are derived by substituting old foreign symbols with the newly created symbols, preserving stride-size relationships. Hint overrides are read from the foreign ShapeEnv and transferred to the new one.r rarfrct|s tjSt|s tjStjSr)rrrr]rrrs rv _classifyzCShapeEnv.transfer_symbols_from_foreign_shape_env.._classifys:q>> )!(($Q'' +!**? "rwrzcnt|r%t|sdSt|jS|S)z:Extract concrete hint. For unbacked symbols returns None.N)rr]rnrqrs rvrkz?ShapeEnv.transfer_symbols_from_foreign_shape_env.._hints:1~~ 6(++ 4-af555HrwNc&g|] }|Srr)rszrs rvrzDShapeEnv.transfer_symbols_from_foreign_shape_env..s!;;;rYYr]];;;rw)rhrirrc3.K|]}|VdSrr)rrrks rvr&zCShapeEnv.transfer_symbols_from_foreign_shape_env..s+22bb 222222rwc3.K|]}|VdSrr)rsdrks rvr&zCShapeEnv.transfer_symbols_from_foreign_shape_env..s+66%%))666666rwc32K|]}|tjuVdSr)rr)rdss rvr&zCShapeEnv.transfer_symbols_from_foreign_shape_env..s*MM2!44MMMMMMrwFrrjrUrrS)r rarfr)r rarfrz)%rrrrrhrrrrqrlr&rrorrrr\rrrrrrArrrrrjrUrcreate_unbacked_symintrrjrpr"STRIDESTORAGE_OFFSET)%rrrWrrNrRrrhrirr foreign_envopt_hintrrr\r ex_strideex_storage_offset has_unbacked old_to_newnew_size_exprsold_szold_exprrrRnew_stride_exprsrnew_offset_expr sym_sizesru sym_strides stride_expr hint_stride sym_offsetrrks% @@rvrz0ShapeEnv.transfer_symbols_from_foreign_shape_envs6 # # # #      #;;;;U;;;M)67#e**DO7+ /      -:M  !Nu%% 5 5EArQ:#666;r??6 g/ **?CCBGLQQH+,4q) MMMMMMMM2222E222226666g66666 !E.11MM}MMMMM  EE!#e**$!1-F ,46 +-"5)) = =IAv6"" =!;+#,,Z88(3z/@/@/B/B+C+CC4,, ,,V^5H!LL%a("#35GHH"(9!<<!)9-C,/Jx("))#...."))(3333%%memF&;&;<<<< .0 ; ;B2 ;7<00<<(3z/@/@/B/B+C+CCG#::<<AFH ''1111 ''  b(9(9:::: ~ & & <,16?? KKO+c*2C2C2E2E.F.FF J"&"="="?"?"D"I+emN;;O // W WFAs1:D   &&//8KQOO'   9R=%,77 W" W''ESTUEV))B-*<*AB '(899  NA{#A,K   &&$//8MqQQ'    ++ "''0MNN,  Y{!3!3Z??rwrris_dim_dynamicSequence[bool]c t|}si|dg|z} dg|z} g} g} t|D]a} || r tj}n jr tj}n tj}| || |btjg|z} tjg|z} t| | | | }t||j } |j } |j }|j} td|Dr tjn tj}td|D}t||kr!t!t|d|t| |kr!t!t| d|t| |krt!d|t| |krt!d|ddlmm|| }|||| | ||}fd t-t/||D}t-|D]=\} }t1|t2jr| vr| j|jj<>g}t-|D]\} }|t!d | |j}t1|t@tBj"j#j$frtA|}n|| }|%||j&|  %'|j(|d| |j( }tS|tS||fS)Nrhrirjrkc36K|]}|tjkVdSrrrrrIs rvr&zIShapeEnv._create_symbolic_sizes_strides_storage_offset..s*AAa1 ))AAAAAArwc36K|]}|tjkVdSrrrs rvr&zIShapeEnv._create_symbolic_sizes_strides_storage_offset..s*MM!qJ$55MMMMMMrwryzlen(constraint_sizes) != zlen(constraint_strides) != rr)rc g|]D\}\}}|||j|ES)r)rrr) rrrRrurr\rrrNs rvrzJShapeEnv._create_symbolic_sizes_strides_storage_offset..ss   ;C  " "#''400++FN4GKK #     rwzstride_expr is None for index r dynamic_dimconstraint_dimrR)*rrrrrrrrUrrrVrjrkrhrir0rmrrr\r_compute_symbolic_striderrrjrpr"r&rqrorrrtrr_r`rrrrrr)rrrrrrNrRrrXrjrkrrirrIrhdynamic_offsetare_sizes_staticrrrrRrrrrrr\s` ` ` @@rvrz6ShapeEnv._create_symbolic_sizes_strides_storage_offsets$'ll N  #59FSL 7;fsl L O3ZZ * *"!$("*AA2(")AA"A##A&&&&&q))))&O,s2L)67#=O7* /!1#5      /000+<-@(6 *:AA=AAAAA !J    MM}MMMMM }   $ $ C $6$6!A!AC!A!ABB B   3 & & C$8$8!C!Cc!C!CDD D  C ' ' !BS!B!BCC C ! " "c ) ) !Ds!D!DEE EMMMMMMMM!%!G!G V-n"H" " ..                   #,Cg,>,>"?"?     ** M MFAs#u|,, Mn1D1D;I!;L)#(-8 '//  NA{"$%Ia%I%IJJJ&..t/EFFK+UZ-?-G'HII +!+.. 'l   &&$//8MqQQ'    "33   !$$V^-JKK*#!1   #''0MNN4   Yz!2!24FFFrwrSequence[sympy.Expr]riSequence[DimDynamic]rkASequence[StrictMinMaxConstraint | RelaxedUnspecConstraint | None]r c ddlm} m} dgt|z} i} dt |D} | t | D]\}}| }|t|dz ko ||||dz||dzzk}|dvr|stj|}n||}|tj kr || vr | |}n\|}|tj kr|r tj n tj }| || || j|||||}|| |<|||z| |||z<td| Dst!d | S) Nrrcg|] \}}|| f Srr)rrrs rvrz5ShapeEnv._compute_symbolic_stride..%s"AAA&!SS1"IAAArwrrrrrc3K|]}|duV dSrr)rrs rvr&z4ShapeEnv._compute_symbolic_stride..Fs&11Q1D=111111rwz$All stride elements must be non-None)rrr\rrrrrrrrrrrrr0rm)rrNrrrrirkr rRrr\r candidatesval_listrneg_ircontiguous_stride out_stridedynamic_stride dyn_strides rvr z!ShapeEnv._compute_symbolic_strides NMMMMMMM+/&3t99*<46 BAIi,@,@AAA 0 111" @ @JCAS^^a''FaLGAENYq1u5E$EE f}}%6}"]3// !0!3!Z%<<< ARAR!+CJJ"0J%)@@@1AVJ--z#"&!3!3,,V^5JANN$.'9!'<)9 "4""J#F1I+/7Z+?JwqzC' ( (11&11111 I !GHH H rwrNrRru(int | float | bool | torch.SymInt | None Source | Nonec  |jrl|j||}|td||t}|t j||nd}t|t j rG|5t ||kr"tdt |d|t |}n7t|rd}tt||t||}|S)zCreate a SymInt value from a symbolic expression If you know what the current hint value of the SymInt to be created is, pass it into hint. Otherwise, pass None and we will make our best guess Nsymbol must not be Nonez int(sym)= != hint=fx_node) rrrmrrtrrrrjrr<r"r:rrRrurNrr#rs rvrzShapeEnv.create_symintnodeJs  / F4F33F;;F~$%>???;;FCHHG    5 5 6 6 6 6G c5= ) ) Is88t##()NSXX)N)N)N)NOOOc((CC%S)) dCwGGGHHC rwr`c D|jrl|j||}|td||t}|t j||nd}t|t j rG|5t ||kr"tdt |d|t |}nIt|r|td|tt||t||}|S)z2Create a SymFloat value from a symbolic expressionNr z float(sym)=r!z'hint must be None for unbacked symbol: r") rrrmrrbrrrrjrcr<r!r:r$s rvcreate_symfloatnodezShapeEnv.create_symfloatnodexs8  / F4F33F;;F~$%>???;;FEJJG    5 5 6 6 6 6G c5; ' ' M::%%()RuSzz)R)RD)R)RSSS**CC %S)) #(G#GG73eT7KKKLLC rwrc>|j||fdSr)r+rU)rrRrs rvrz%ShapeEnv._record_exclusion_constraints# "))3*55555rwrYr rexcluded_valuec||||}||||||||S)z1Create a SymInt wrapping a new unspecified symbol)rNr Nr)create_unspecified_symbolrr)rrYrNr r(rRs rv$create_unspecified_symint_and_symbolz-ShapeEnv.create_unspecified_symint_and_symbolsk,, #-    %  - -c> B B B%% &   rwr cJtt||tdS)z7Create a SymBool object from a sympy boolean expressionN)r r:rrrrRs rvcreate_symboolnodezShapeEnv.create_symboolnodes wsD$55666rwprefixrr%r$r)SymNode | Nonec Ptjduo-ttjdv}|||\}}n |jd}}t d|jj |||tdfddS)N,rpz%s %s [%s, %s] %s%s stack_infocreate_unbacked_symbolcttdjdjdt jdt jdS)N[rrr)rnode_idr% user_stackr)ridr(r)r.get_user_stackget_framework_stack)r)rr%srvr|z6ShapeEnv._log_create_unbacked_symbol..sUf++h<<1"(11bh111(7::#799 !!rw metadata_fn) rextended_debug_create_symbolrr_get_stack_summaryrZrrr(r)r/) rr/rr%rNr)is_debugslocmaybe_extra_debugs `` ` rv_log_create_unbacked_symbolz$ShapeEnv._log_create_unbacked_symbols6dB&*&=&=h&G&G #D##&,k2#D  !   H H      $ rwr!cttj|j}|xjdz c_|jdxxdz cc<|s|j|tj d|j |<tj x}|j |<|jstd|}t#|||j|<||t(}t+||t(d|}|d|||t/|S) z,Create a symbolic float without a hint valuerr5rvr must be floatNr"create_unbacked_symfloatr))rPrSr6r.r6rrrUrXextractr%rWunknownris_floatrm _get_slocrr$rrbr:rDr!rrr%rBr#r)s rvrHz!ShapeEnv.create_unbacked_symfloatsX +  !?   &&!+&& -...!3...6688 ?  / 6 6v > > >$5$=1$E$E$E&!)4)<)>)>>T v &{ 5 !344 4~~)8t)D)Dv&77FF64gFFF (( &X )   !!!rwcttj|jd}|xjdz c_|s|j||jdxxdz cc<tj d|j |<| x}|j |<|j std|}t!|||j|<||t&}t)||t&d|}|d |||| t-|S) z.Create a symbolic integer without a hint valueTrirr5rFvr must be intNr"rrI)rPrSr5r/rrrUr6rXrJr% _default_unspecified_value_rangerrrmrMrr$rrtr:rDr")rrNrr%rBr#r)s rvrzShapeEnv.create_unbacked_symintsd +  t;T    $$)$$6688 ?  / 6 6v > > > -...!3...$5$=1$E$E$E&!)-)N)N)P)PPT v &y 3 !122 2~~)8t)D)Dv&77DD64dGDDD (( $fb&8 )   hrwc6t|tjS)zJCheck if a sympy symbol matches the naming convention for unbacked symbols)rRrSr5)rrs rvrzShapeEnv.is_unbacked_symintsfd&7888rwsym_intshape_idrc|dS|j|}||jj|j|<dS||d}t j||kdS)aH Dedup unbacked symbols sharing a `shape_id` via a runtime equality check. The first symbol for a `shape_id` is recorded; subsequent symbols emit `torch._check(new == existing)` so the ShapeEnv learns the equality without changing symbol identity. No-op when `shape_id` is None. Nr)rFrrqrorrpr)rrSrT existing_symexisting_symints rv_add_shape_id_eq_checkzShapeEnv._add_shape_id_eq_check su   F8< > > -...!3...$5$=1$E$E$E&!)4Q):)::T v &y 3 !122 2~~HII)8t)D)Dv&77EE58FA..dD'RRR (( %vrH )   x   rwint | SymInt | float | SymFloatr rcc :|||||dd|S)z Create a symbol with an unspecified value Compared to standard symbols we do not assume the value is positive, nor do we specialze on zero or one values. NT)rrrR)r)rrrNr r rRs rvr*z"ShapeEnv.create_unspecified_symbolMs6(!!    '+-"   rwr rrc t|tr|jj|jjkrt j}|jjkr'td|jjddjt|triddl m }t|stdtjtd||jj<d|jj<d}j} t|t"r-t%||jvri|jt%|<t|t"r>| r<| |jt%|vr |jt%|| S|t jurd} d} d} t|trC|j<|?tb|r |j/<ttbrA|rk|@dk|A||jB<t|+|j$rdnd||jD<n4|E|jB<t|||jD<t|tr.|rtd|F|jd|jB}|jGstd|vr"td|jd|jdd|jd|jdnttrrqttNjI tNjIx|jB<}t|||jD<d|jd|jd|jJstdnd}tjLduo-ttjLNdv}d}|stjPdd d!vrd"d#}|Q|\}}|jRSd$j||||% td&fd'(|jUd&xxdz cc<n8|j/}||j7| <|jRVd)|jt|tNjWrq|j>|}|XYs1|dYr|d*|dc|d<|d*<d|jZ|<t|t"r| r||jt%|| <|S)+z5Create a new symbol which is tracked by this ShapeEnvzStatic shape constraint of z does not match input size of z, for rr[z#Expected TensorPropertySource, got Nzsource.idx must not be NonerFrz!positive set for negative value: zunhandled dynamic_dim rTr)rrr)rrzuser code shown is first use of this value--the guard itself is not due user code but due to 0/1 specialization in the framework; to avoid specialization try torch._dynamo.decorators.mark_unbacked(tensor, dim)z-duck must be False for StrictMinMaxConstraint is_constraintrPz not in range [rrr7rGrpr2TORCHDYNAMO_EXTENDED_ADVICE1)0rpzC, for more info run with TORCHDYNAMO_EXTENDED_DEBUG_CREATE_SYMBOL="zF" or to suppress this message run with TORCHDYNAMO_EXTENDED_ADVICE="0"z&create_symbol %s = %s for %s %s %s%s%sr3rc ttjtjt jtjtjd dS)NrrF)rrr%rNr9r) rrrZr.from_tracebackr) extract_stackrXrJsummary) range_strrN sympy_exprrsrvr|z(ShapeEnv.create_symbol..|st!*oo99#$k",";&466##(6)1q999AACC % %rwr=zcreate_symbol %s duck sized %srS)[rjr#r%r(r)rrrIrZrrr\rmrsrrhrjrr:rxrrorrprrqrorrrprrr"rXr=rrr(rrrrrrMrrr r-_generate_unique_idrtrrPrSrFLOATr'rrbrcrN nested_intrrrr_default_value_rangerrr$rQ_update_var_to_rangerrWoorLrr?rrr:getenvr@rrr/r6rrrU is_ephemeralr7)rrrNr r rrrRr\rrT unbacked_min unbacked_maxboundsr out_symintout_symrduckrB symbol_idr%rIrAmaybe_more_inforC r_sourcesrgrhs `` @@rvrzShapeEnv.create_symbolks_  ~'= > > "!'>+<+BBB$+K &#--.).2C2I))il))!;))*,DEE EEEEEEE!&*>??(Ld6llLL:%()FGGG=H .vz:@D 1&*=!Nk ')@ A A P4 0 TTTMO  @D J ')@ A A  #G4QRR$G4Q  *- - -HLL+-EFF J$.:EEEEEEf&:;;J @V/9==fjIIH+-EFF <$4@EEEEEEf&:;;< @V-=AA&*MMF)5;2 l--f55:?C  * *3 / / /'<+C!33Cd3CC +L|!;<<<+L|!;<<<#vt'='=c'='M'MNN++GX>>>  $ $S ) ) )*,CDD  !DRXXNJ % ;"'  "&": &&)) = DLL!;!;6!;!;<< <  L :+>>>377 !JS!J!JKK K  %$,K *+ + +-$$C*,CDD  !DRXXNJ JO + +?DD J. . .DD !G+!G!GHH H~~ &==0=axxw|#w{"N MDO3300==ICyyC=#5#5(Iy8T )J H4 /9D { +#s## 5:]35G5G&z22C'' 5:[5E5E&z226BH''))1J1J1L1L666&z2 /1D  + OOJ , , , 2(2$#s##7 U'' Q777594M4M255D%j1:I $7&kk"&  : :D*:66==??%j1:It9T9TD*:6n.DEE,K--"N$5T.&z2y;()9:::b==2FFrxFF28FFF877BH777 C'' 5@%(EH5U5UU!*-5DT45P5P&z2777BH777 {=();<<<=  A:$F@3LL4::3??L@H!O  *G M MV!! 6AK666 '+&=&=h&G&G #D# HMM8 !#                 L ) ) )Q . ) ) ) )$A./D { + HNN;Q L L L a & & -+A.I   V $ $ $&&(( JYq\-F-F-H-H J.7mYq\+ ! im ,-D %a ( &(? @ @ [   @D J rwctd||d||jvrt|dt j||j|<dS)z.Adds a new symbol to the symbolic environment.zadd_backed_var_to_val %s %sTr3z already existsN)rrrrmrrrrors rvadd_backed_var_to_valzShapeEnv.add_backed_var_to_vals_ /st LLL 4) ) ) D!9!9!9:: :',}S'9'9t$$$rwz7var_to_val is deprecated, use backed_var_to_val insteadrl!dict[sympy.Symbol, sympy.Integer]c|jS)z*Deprecated: use backed_var_to_val instead.)rrs rvr4zShapeEnv.var_to_vals %%rwz?add_var_to_val is deprecated, use add_backed_var_to_val insteadc.|||S)z.Deprecated: use add_backed_var_to_val instead.)r|r{s rvadd_var_to_valzShapeEnv.add_var_to_vals ))$444rwcF|j}|j||Sr)rZr-r)rrNsrc_names rv _debug_namezShapeEnv._debug_names";-11(HEEErwr0StrictMinMaxConstraint | RelaxedUnspecConstraintct|tr|jj|jj}}|}||jkrd}||jkrd}||d|jd}|$|"|d|d||d|z }nE|!||d||d|z }n"| ||d|d||z }|S||S)Nrz in the specified rangerr') rjr#r%r(r)rlrrZr+)rrNrr(r)rc_renders rv&_render_range_for_constraint_violationz/ShapeEnv._render_range_for_constraint_violationsE a/ 0 0 4:qtz5E//11G %% %%##F++TT TTT  U%6PPP4+;+;F+C+CPPPPP5#4E 0 0 8 8EEeEEE"u}EEE4+;+;F+C+CEEEOxxrwrc:|j|i|ddidjS)z Like produce_guards_verbose, but only returns the non-verbose python guard expressions (no verbose guards produced.) langs)pythonr)produce_guards_verboser")rrrs rvproduce_guardszShapeEnv.produce_guardss/ +t*DNFNN+NNNqQWWrwc|jSrr]r)s rvr|zShapeEnv.srwrverbose_python)rBinput_contextsequalities_inputs _simplifiedr r placeholdersSequence[FakeTensor]rSequence[Source]rrrBlist[ShapeGuard] | NonerDimList[SymbolicContext] | NonerEqualityConstraint | Nonerr rtuple[str, ...]list[_ShapeGuardsHelper]c. STUVWXYZ[\]^_`abcjdjr)tj} | t t |krtdd|dtj tfUdtd V|UVfd D}nt |t krtd tt|D]\} \} } t| Ur| V| || <)t| ttt t"fstd t%| t| t&rtdddlmSmTgZt/jt&ct/jt2bgXg]t5c|j^ D]]}|dvr]^|dkr*]t;c|jLt=d| dudvXfd _dwSTfd [|ri`t|D]\} }| `|j<dx`fd$ }|j D]\}}||||}}!tEj#||}|stI|jd%t|tr|n|%j&d&|jd%t|tr|n|%j&|j'D]6\}}}||}t|tDj(r|j|dj}}nLt|tDj)r|tU|}}n ||+|}}||}!tEj#||}|sntId'|jd(|tEj(|d)|d%|%j&d*|%j& 8|j,D]B}t|tDj(r&c|-j|C dudyZ^_bcfd0 }dzcfd1 }d{Zcfd3 }t||D]\} }} t|tTrdd4lm.} | |}t|t^std5t%|| dt| ttfr#| d nta| d.d }!||| |!t| t t"fr ||| t| Ustd6t%| tc| rdd7lm2}"t| tfstd8t%| g}#| j4r$|#|| | j5| j6fnt| 7D]!\} }$|T|Sj8| |$"t| 9D]!\} }$|T|Sj:| |$"| ;\}%}&|%D]}'ta| |'xxtj d9x?\}(| j<|'})|#|"||'|(|)j5|)j6faxtzd9x\r}*td:t%|*n|| | j5| j6fg}#|#D])\}}+},}-t}|+rMt|+7D]*\} }$T|Sj8| }.||.|$|,| +dt|+7D]*\} }$T|Sj8| }.||.|$|,| +t|+9D]*\} }$T|Sj:| }.||.|$|-| +|T|Sj?|+@+d; DWtcj&t3bBjC_D|sZD]\}Y|j}/jEr<|/jFvr3GtEj#jF|/YtYtDj(r(cHYr|cYdkr|rAt|Tr1YjIr*jJd<||d=Y[|rjDK|YtW] D]\}0}1}|1L|d=|1MY}2|d>kr|jNH|/x}3X|j|3dkr|2d?j&|3d@}2n5jOH|3x}4|2dA|4}2n|2dB|3dC}2n|2dD|/dC}2|0|2t|Tr|jPSj8ur|rt YjQdEkrttYjQatYtDj(rYbvr|T|cYds|dF+|d%|jdG+cYdd%cYdjdH }5_|jU+||5tYtDj(sabvr|V|cadYafdIsʼncad}dF+|d%|jdJ+|d%|jdK+|d%Y%atEjW+|idL }5_|jU+||5t3\d|W[\ ]^_bcf dO }6||njXD]1}7Y|7jZd9|7j[P &|6|72j\Hd gD]S}8Y|8jZd9Q]|8jZYjD^YTc_D]6\a}j`Ha}9|9#jaa}:|stdRag};||d}tW] D]J\}0}1}|d>kr|0|="|0|1M|>Kba}?|?D]}@t|@tr|@jlgzm|9s|d}tEjjtEjh|9jbatEjha|9jiY^MY}An||@}BdZ|Bd[|A}5_|@jU+||5tatjqrd\^L|dd}2tW] D]\}0}1}|d>kr|0|2d]%|d^kr|0|2A|dkr3|0d_|1L|ddzt=d`|8dd lrmscmt}C|Cjur|Cjvs߉jwr؈cfdajwD}D|Drtfdb|DDst |DdEkr0tEjy|Ddd|DddEdUV}EntEjzdc|DD}EtW] D];\}0}1}|1M|E}A|d>kr|Add}A|0|Adg|J}K|G|K|H^|vt |GdkrLdh{t|H}Ldi{|G}MtIdj|Ldk|Mt |Fdkr(tJdlt |Ftdmdij~jt WdtdncDtjdopdqjErDddrlm}Nj\D]!}O|OD]}8G|8jZ"j`_D]\}P}Q|QjbtDjc t fvr-GtEjh|Qjb|P|QjitDjctfvr-GtEjh|P|Qjit j5|Njjd d d n #1swxYwY|g}RtW] D]\}0}1}|dkr^t|1t:stdst%|1|Rt|0|1jFj|Rt|0|RS)}a Generates a list of guards strings which, when evaluated in a context that defines tensors for all the sources, returns True or False depending on if the guards in the list evaluated to True or not. Primarily used by Dynamo, but this is also helpful for manual testing of guards (see evaluate_guards_for_args) For convenience in testing, a source is allowed to be a str, in which case we will assume it is a LocalSource simplified lets you omit duck sizing, equality and 0/1 guards. This is useful for testing when you don't care about the boilerplate guards, and it may be helpful for user output too (be careful though; some equality guards are nontrivial! It would be nice to get simplified output to print them too). It's private because it's not intended for normal use Returns guards in python and python with verbose comments (verbose) by default. rzlen(z ) != len(rnrrZrf"StatelessSymbolicContext[..., Any]cttjg|ztjg|zdg|zdg|zS)Nr)rrrrXrrs rv_create_no_constraints_contextzGShapeEnv.produce_guards_verbose.._create_no_constraints_contextsk,)12QUUWW.#sM6@:5N5NX..q111TXrwz(len(input_contexts) != len(placeholders)z.Expected SymInt, int, SymFloat, or float, got zcontext must not be a listrrrcppzUnknown lang: r rrrrrruCallable[[], str] | NonercD||fdfdS)Nc(rnSrr)rursrvr|zVShapeEnv.produce_guards_verbose..record_constraint_violation..s"D0Q30@0@0@0@crw)rU)r rrruconstraint_violationss ``rvrecord_constraint_violationzDShapeEnv.produce_guards_verbose..record_constraint_violations@ " ( (J(Q(Q(Q(Q(QR     rwrGrTypeGuard[TensorPropertySource]c@t|o |jjuSr)rjpropr)rGrr\s rvis_dimz/ShapeEnv.produce_guards_verbose..is_dims(3 4554H 33 rwtensor_dim_srcr(rcb|jj}|jtd|j|j}t |t jr |jj St|turtdt|tj |S)Nz#tensor_dim_src.idx must not be Noneri)rrZrrmrOrjrpr"rqrorsrtrr)rr~symintr source_indexs rvget_expressionz7ShapeEnv.produce_guards_verbose..get_expressions#L1D1I$JK!%-()NOOON$67fel331!;++F||3..,-P$v,,-P-PQQQ =000rwrz is not equal to zExpected input z to be equal to z, where z , but got rNrrardrcc .tdtfd||t|trt |st dt|tr2|j|j}t|tr|jj }t|tj rO| |0t|ts||nd}t|trAfd|jD}t#d|Drd}n1t|tr|jrt)|}|dvrd}|r|t d d fd }|}d|dd}  |j| t1j|| |fdStj|} |fd}t|tr&||jjcxkr|jjksnd}nt|tr|dvrd}|r|t d |}jd} dd|d| r*dd | !zndz}  |j| dSdS)Nztrack_symint %s %s %scjSrr]rsrvr|zGShapeEnv.produce_guards_verbose..track_symint..s 6;rwz&val must be symbolic if it is a SymIntFcHi|]}|j|dSrrrrrrs rvrzIShapeEnv.produce_guards_verbose..track_symint..s;###BCAt044Q==###rwc3K|]}|duV dSrr)rr%s rvr&zHShapeEnv.produce_guards_verbose..track_symint..s&EEbrTzEEEEEErwTrzconstraint must not be Noner rrfrc8|}|dSrh)r)r sexpr py_printers rvruzCShapeEnv.produce_guards_verbose..track_symint..hints"$.$6$6q$9$9E&+;;;.rwNot all values of z are valid because z was inferred to be equal to rz You marked z; as dynamic but your code specialized it to be a constant (z). If you're using mark_dynamic, either remove it or use maybe_mark_dynamic. If you're using Dim.DYNAMIC, replace it with either Dim.STATIC or Dim.AUTO.z User stack: rp)r rrfr)"rrr-rjr"rrmrq maybe_as_introrrrUr.rr#rrrr.rtrrr rrrr%r(r)r=rr@format)rNrrdr constraint_violatedsym_vrsrruvar_with_rangerr9 input_guardsrrrsymbol_to_constraintsrs` rv track_symintz5ShapeEnv.produce_guards_verbose..track_symintsh II'....//     #v&& O{3/?/? O$%MNNN#v&& .38+@+@+B+B+Nh++--#v&&R HMa..+$Q'..v666!-j"$;77-.a044Z@@@*/'!*.DEE;####GH~###EEGNN4D4DEEEEE726/#J0GHH;;; #AA !6: 3*%-"01N"O"OO//////*.)T)T"J**WWW#//77WWW43&0 ,,V44!*!24!;!; ##VQK00000M#&&##VQK000&+#j*@AA 3Z]0GGGGJM4GGGGG.2+ ,CDD3&((.2+&!),-JKKK%)%P%P &&N"&!;!?!?!M!MJJd&6&6v&>&>JJ.>v.F.F%rwc<t|trt|rr|jj}t|t jrNtj|tr#| |dSdSdSdSdSr) rjr"rrqrorrrrrNrU)rNrr rrs rvtrack_singletonint_sourcezBShapeEnv.produce_guards_verbose..track_singletonint_sourceJs#v&& 7;s+;+; 7HMa..7:*..q11<447%Q'..v66666  7 7 7 77777rwr`ctdtfd|t|trt |st dt|tr2|j|j}t|trZ|jj }t|tj r|  |fdStj |} |fdS)Nztrack_symfloat %s %scjSrr]rsrvr|zIShapeEnv.produce_guards_verbose..track_symfloat..Ss rwz(val must be symbolic if it is a SymFloat)rrr-rjr!rrmrqmaybe_as_floatrorrrUrc)rNrr rrs` rvtrack_symfloatz7ShapeEnv.produce_guards_verbose..track_symfloatRs* II,j9L9L9L9L.M.Ms S S S#x(( QS1A1A Q$%OPPP#x(( 0SX-D-D-F-F-Rh--//#x(( 1HMa..7$Q'..v666##VQK00000K$$##VQK00000rw LocalSourcezExpected Source, got zExpected Tensorlike, got ) AttrSourcez&Expected SubclassSymbolicContext, got rz#expected Tensor or OpaqueBase, got cg|]}gSrr)rrs rvrz3ShapeEnv.produce_guards_verbose..s%8%8%8Qb%8%8%8rwzSkipping guard %srrzN # duck sizing added this equality because these variables had the same size zY (to avoid this specialization, set torch.fx.experimental._config.use_duck_shape = False) # z # (unknown var z, please file a bug)z # (unknown source rzThe values of  and z must always be equal.c2|iSr)r)rrors rvr|z1ShapeEnv.produce_guards_verbose..*sdmmVQK&@&@rwz) must always be related to the values of z by r\guardr&c& |j}|vrdS| d}tfd|jDr0jt dj|}t D]B\}}}||}|dkr |d|j }| |C ||st|jdkrtt|j}|d}|} | D]} t| t rX|| } d| d |d } | j|| ot| t(rt d | dSdSdS#t*$r"jd |j wxYw) NFc3DK|]}|D]}|VdSrr)rr rNrrs rvr&zGShapeEnv.produce_guards_verbose..issue_guard..Ls["21"5F6NNrwz dim_constraints must not be Nonerrrrr satisfy the generated guard r\zunrecognized constraint zFailing guard allocated at %s)rvrorrrr4rmrrrBrUrrr'r^rjr#rr rr.rrr)rro is_trivialr"printerlang guard_exprrrN constraintsrrr all_exprsrissuedrprintersrrrrrs rv issue_guardz4ShapeEnv.produce_guards_verbose..issue_guardAs==,,Dv~~ JJt   . " !.@ +3,-OPPP!%!5!9!9$!?!?J,/ 8U,K,K--(E7D!(!6!6J///(2%D%D %D%D LL,,,,%%d+++"Qc$*;&<&<&A&A!$t'8"9"9::F-f5a8F"7"?K(QQ%a)?@@Q $ K KFTU V V+![^![![?I?Q?QRV?W?W![![![ 87 ! T-=-=f-E-Es(+BCCQ !"01OA1O1O"P"PP/QQ&A&AQQ(     !@%*MMM s F&G$$,Hr!r)r!z%sources must not be empty for symbol rpc3.K|]}|VdSrrrrNrs rvr&z2ShapeEnv.produce_guards_verbose..+<<&vvf~~<<<<<.rrwrrrznot math.isnan(zM # implicit guard for float input due to NaN specialization in the frameworkrz ~std::isnan(zUnimplemented for lang: cHg|]\}}|||fSr)r)rrRrrs rvrz3ShapeEnv.produce_guards_verbose..#sEC#'',,c rwc3ZK|]%\}}j||kV&dSr)rr)rrRrrs rvr&z2ShapeEnv.produce_guards_verbose..(sN%%;C3&**3//36%%%%%%rwcBg|]\}}tj||dS)Fr)rr)rrRrs rvrz3ShapeEnv.produce_guards_verbose..1s-WWWc%(3e<<<WWWrwz) # exclusion guard for automatic dynamicz . z - rrzConstraints violated (rz$%s Warning only constraints violateddynamicc3K|]}|dV dSrNrrs rvr&z2ShapeEnv.produce_guards_verbose..Zs'#N#N!A#NA#N#N#N#N#N#NrwT)reverse) num_guardsrsymbol_guard_counts)PopulateValidatorz$Expected _ShapeGuardCppPrinter, got )rrZrfrr) r rrrrrrrurrfr)rGrrfr)rr(rfr)rNr(rrardrcrfr)rNr(rrarfr)rNr(rr`rfr)rr&rfr)rrrr7rrdrrmrprZr5rrrjr"rtr!rbrsrVrrr\r5r rAr rrUrrrZr2 evaluate_exprrrrIrrr3rrrrr4extendrr(r`r>rrr|rjrkrrrrrr{r0r1rrr3rr-r4rrrrr.rrerrr'r)rrr'r^rNr rKrrBrrorr0rvrrrr$r(rnrJrrrlrr)rr#r%rrrRrSrjtorch._dynamo.configr-r!automatic_dynamic_exclusion_guardenable_compiler_collectivesr+r0rrr@rr2rr6sumrr7rr fx_tracebackpreserve_node_metarDrArunrr$r!)drrrrrBrrrr rrlrrcontextrrGrrLrMexpr1r concrete_valsrcEqr@rArexpr2_phantom_symbolrrrrNrrdrsources_tensors_constraintsssrrrinner_t inner_context unexpectedcurr_tconstraint_sizeconstraint_strideproperty_sourcerr"rrs0rBrrrr`rIvr_slocrsrf verbose_exprboundrrrr dynamo_config all_pairs excl_expr warn_msgs error_msgsrr msg_cbstr_msgdebug_names_strerrrrarRr%helpersrr\rrrrrorrrrrrrrrrsd`` ` @@@@@@@@@@@@@@@@@rvrzShapeEnv.produce_guards_verboses/H  &'''  % (/ <""c,&7&777$%OPPP#,S~-N-N#O#O K K >   #C ( ( LN-/, j$*=   C CD333 ++++)(*d6I **A4*A*ABBB .2                9 L#G,, + +3)* SX&& 1 1 1 1 1 1 10<   d-~d33^^D5I5Iu $11%(5%2H2HII #29ww*UC2H2H)tenn]a]sNtNtww9ww2N>Nt>T>T:EE $11%(5&2I2IJJ #2L%*LL2el:6677LL!+LL05t?U0V0VLL$)>>$2H#I#ILL#4"C  nel;;$^4;;+N; KOa a a a a a a a a a a a F 7 7 7 7 7 7 7 1 1 1 1 1 1 1$#&lG^"L"Lh h  Avw&#&& -<<<<<<$V,,ff-- M$%KT&\\%K%KLLLy!fc]++ #ODD,PT1U1U VQ 333A%011 vq)))a,, L$%Ja%J%JKKK,Q//7 ;;;;;;!'+BCC(PgPPSU+2/66"#4#6 "+16688!4!4211009LaPPRT"+188::!6!6211009NPQRRTV//11q!D!!T**66U\^^^^^^^,3,B4,HM7>>$.Jvt$<$<$+$1$B$1$D !"76*Z\\\\\\ *'"0 Xd:FVFV X X##(Q 8':TU/+-   ! ((!*6;;==!9!9NN2*>*>!4a++% _b/!:LMMMM N "+6;;==!9!9NN2*>*>!4a++% _b/!:LMMMM!*6==??!;!;PP2*>*>!6++% _b:KA:NOOOO L,,S.2OPP--//1 B&9%8%%8%8%8 -   " %**,, - -  *   Z  ,Y Y   +7$"777--!HT%:7%CTJJ tU\22(,,T22"24"8";;; !!Z8L%M%M!~!/JJv4F4F1R1RD1R1R!6&>>D(55fdCCC,/ 8U,K,K&&(E7D$11&99VVwt?T?TVVC///"&"4"8"8"A"AABN%)>J==))D  $ $T * * * * 05577L UL UOFG!%%f--Ay,V4G W$%UV%U%UVVV(*FGAJ''BLwy6'222<<<>Q&& %!! Q1a5!!!II!&WWYWWW!I-0 8U,K,K--(E7D!(!;!;J///)TTT#LL,,,,  R#%I$&J%%K1F 0 0- :v0C3y>>A#5CCCCG$$W----/VVXX//G%%g...OOJ////:"""&))F;,?,?"@"@ii ++._ Y!## @#i..QQQ   . , ")A,// ##N#N/?/F/F/H/H#N#N#N N N(.-4466(((       / D I I I I I I 4;;== 3 333B))"'22223  ,2244 C CR8UXIw#777))%(28S*A*ABBB8EHf#555))%(3*A*ABBB022 D D!!$*dn==AACCC D D D D D D D D D D D D D D D >  , , . . .,.$' 8U$C$C : : E7Du}}!'+@AA(NtG}}NN4UG.s???WWW???rwc&g|] }|Srr)rrdrs rvrz6ShapeEnv.produce_guards_expression..s! / / /[[^^ / / /rwrrN)rrrrrr@)rrrBr  arg_namesproduced_guardsrs @rvproduce_guards_expressionz"ShapeEnv.produce_guards_expressions 544444??eC ,=,=&>&>??? --  / / / /Y / / /' .    1<<00 0trwcodeint | float | boolctd|jD}t|t|S)z? To be used by compile_fx to evaluate symexprs c4i|]\}}t||Sr)r)rr%rs rvrz-ShapeEnv.evaluate_symexpr..s$III3AIIIrwrrevalrrrrs rvevaluate_symexprzShapeEnv.evaluate_symexprs9JI$*@*F*F*H*HIIID,---rwrzczfdjD}t|t|S)zB To be used by compile_fx to deserialize symexprs c i|]F\}}t|tt|tt|dGS)Nr")rr"r:rt)rr%rrs rvrz0ShapeEnv.deserialize_symexpr..sV   3 FFF71dCS4HHHII   rwr r"s` rvdeserialize_symexprzShapeEnv.deserialize_symexprsN    06688   D,---rwSequence[object]c dtt|D}t|tdt t ||iS)z Expected to be used with produce_guards_expression(). Evaluates an expression generated by produce_guards_expression for the given concrete args. cg|]}d|Srrrs rvrz7ShapeEnv.evaluate_guards_expression..s777WWW777rwL)rrr!rrr)rrrrs rvevaluate_guards_expressionz#ShapeEnv.evaluate_guards_expressionsN 87eCII&6&6777 D,d3y$3G3G.H.H(IJJJrwr Sequence[Tensor]cd|||}|r|||SdS)zRGenerate guards for a graph's placeholder values and evaluate the guards with argsr T)rr+)rrrr rs rvrz!ShapeEnv.evaluate_guards_for_argss?--l--XX  ?224>> >trwsymintsSequence[torch.SymInt]list[ShapeGuard]cFdDfd|jD}|S)z Get a list of guards, but pruned so it only provides guards that reference symints from the passed in input cnh|]2}t|jjtj&|jj3Sr)rjrqrorrr;s rvrz-ShapeEnv.get_pruned_guards..sA   Jqv{EL,Q,Q FK   rwc^g|])}tfd|jjD'|*S)c3 K|]}|vV dSrr)rr r.s rvr&z8ShapeEnv.get_pruned_guards...s')T)T1!w,)T)T)T)T)T)Trw)r0ror)rr]r.s rvrz.ShapeEnv.get_pruned_guards..sP   c)T)T)T)T@S)T)T)T&T&T    rwrB)rr.rBs ` rvget_pruned_guardszShapeEnv.get_pruned_guardssR   !(       {    rwrc|id fd }t||D] \}}| t|tr |||+t|tjst dt |t|D]$\}}||||%t| D]$\}}|| ||%|| | "S) a5 Given a paired list of placeholders (fake tensors with symbolic sizes) and concrete arguments (regular tensors with real sizes), returns a dictionary mapping each symbol to its real value. So for example, if you have a placeholder with size (s0, s1), binding (2, 4) to it will give you {s0: 2, s1: 4}. This is not guaranteed to bind ALL symbols in the ShapeEnv; we can't bind a symbol if it doesn't occur in any placeholder, and symbols that already have replacements won't get bindings. This is a little duplicative with evaluate_guards but it's different enough that it seemed cleanest to make another copy. This assumes the guards are already checked, though if it's cheap we'll check for shenanigans r7rrrfrct|trt|tstdt ||jj}t|tjr3|vr(||krt|d|dS||<dSt| tjr<| vr,| | krt| d| dS| | <dSdSdS)Nriry) rjr"rtrmrsrqrorr)r7rr rs rv bind_symintz*ShapeEnv.bind_symbols..bind_symints8#v&& ,!#s++K()Id3ii)I)IJJJHMa.. ,H}}#A;#--"0HQK1J1JS1J1J"K"KK.-'* EL11,rX~~#QB.>.@.@ A A A Arwlist[SympyBoolean]c*fdjDS)zSReturns a list of guard expressions that aren't statically known (i.e. not trivial)cg|]?}|jd|j %|j@S)rr)rrorrv)rrrs rvrz2ShapeEnv.get_nontrivial_guards..se   ** 2e6J+ MM%* % %rwr5rs`rvget_nontrivial_guardszShapeEnv.get_nontrivial_guardss0        rwverbosecPdfd|jDS)zQFormat this shape env's guard expressions with optional traceback info if verboserc3bK|])}d|jrdt|jzndV*dS)z - rrpN)rorrB)rrr>s rvr&z)ShapeEnv.format_guards..s^   I%* HwFcC OO33B H H      rw)r@rB)rr>s `rv format_guardszShapeEnv.format_guardssCyy          rwrcfd|jD}|r?j|zD]"}||tdt||<#t ||S)zPGiven a sympy expression, computes a ValueRanges bound for what values it can becHi|]}|j|dSrrrs rvrz(ShapeEnv.bound_sympy..(s.UUUa4,00D99UUUrwNr)rr,rrWrJrT)rrorrrs` rvrTzShapeEnv.bound_sympy#s~ VUUU4CTUUU  =^l&7&7&9&99 = =?.'2!V&<&.AsJQSLMrwc3tK|]2}|jv j|dD] }|jV 3dS)rN)rr0rro)rr rIrs rvr&z&ShapeEnv.get_axioms..EscD2226::1bAA3222222rwc3$K|] }|jV dSrrrr\s rvr&z&ShapeEnv.get_axioms..Ks$)F)FQ!&)F)F)F)F)F)Frwc3fK|]+}t|jV,dSr)rrr)rrdrs rvr&z&ShapeEnv.get_axioms..NsN'qzz$2H'I'IJJrw) r0rrBrrrrfromkeysr)rrjrEruntime_assertsrBr!s` rv get_axiomszShapeEnv.get_axioms5s ?!%!>!E!E!G!GOO O *G)F$+)F)F)F)2)Q)Q  FT]]6**//11222rwr%@tuple[tuple[SympyBoolean, sympy.logic.boolalg.BooleanAtom], ...]c@id fd }||t|tjrU|tj|j|jd|tj|j|jdnt|tjr|tj|j|jd|tj|j|jd|jj r9|jj r-|tj|j|jdz dnGt|tjr-|tj|j|jdzdt S) zGGiven a expression, it returns a list of predicates that follow from itrorrfrct|}t|tjtjfrt|tjr tjn tj}tjt ||j|jd<tjt ||j|jd<tj ||j|jd<tj ||j|jd<dStj|<tj ttj |<dS)NFr) rrjrrrr\rsrrr]r)rorequivs rvadd_exprz+ShapeEnv.get_implications..add_expr[s)$//D$58 455 M(2$'A'AO588uxHM jd4jj48eDDDEHM jd4jj48eDDDEFKkhhtxEBBBCFKkhhtxEBBBCCC$jd BG,UYt__==>>>rwFrrrorrfr) rjrrrrrrrr is_integerrr)rr%rTrSs @rvrQzShapeEnv.get_implicationsTs FH M M M M M M&  a " " A HUXaeQUU;;; < < < HUXaeQUU;;; < < < < 58 $ $ A HUXaeQUU;;; < < < HUXaeQUU;;; < < <u EAE$4 E!%UCCCDDD 58 $ $ A HUXaeQUQY??? @ @ @U[[]]###rwrc|jr)|j|}|duo |jdkS|jr|dkSdS)zWCheck if a single term is non-negative (symbol with non-neg range or non-neg constant).NrF)r4rrr(r.)rrr%s rv_is_nonneg_termzShapeEnv._is_nonneg_term}sP > 4"&&t,,BT>3bh!m 3 > 19 urwct|tjs||S|jD]}||sdSdS)z Check if expr is a sum of non-negative terms (Add of symbols with non-neg range and non-negative constants). Returns True only for simple Add expressions. FT)rjrrrXr)rror7s rv_is_nonneg_sumzShapeEnv._is_nonneg_sumsh $ ** .''-- -9  C'',, uu trwrsympy.Basic | Nonec t|jdkrdS|j\}}t|tjr |dkr|}n%t|tjr |dkr|}ndS||r tjSdS)z Fast path for trivial comparisons: sum of non-negative terms >= 0. Returns sympy.true if pattern matches, None otherwise. rNr)rrrjrrrrZr\)rrorrsum_exprs rv_maybe_fast_eval_comparisonz$ShapeEnv._maybe_fast_eval_comparisons ty>>Q  49S dEH % % #((HH eh ' ' C1HHHH4   x ( ( : trwrycfd|jD}t||}|r|jS|S)a& Lightweight range-based evaluation using only bound_sympy (value range analysis), without expensive simplification, axiom matching, or symbol reallocation. Returns the resolved value if range analysis determines it, otherwise returns fallback. cFi|]}|j|Srrrs rvrz7ShapeEnv._maybe_evaluate_range_only..s,MMMaa*..q11MMMrw)rrTrkr()rrory var_rangesrs` rv_maybe_evaluate_range_onlyz#ShapeEnv._maybe_evaluate_range_onlysRNMMM4;LMMM $ ++      9 rw)rrErr!rrr!tuple[SympyBoolean] | Noner:tuple[tuple[sympy.Symbol, ValueRanges[sympy.Expr]]] | Nonec & |r|rtd||}|r2|jj}t |}d fd }||jj}nyi}|D]i} | j|jrH| t | j||||}|j} | s|j s|j r|S|j nt| t fdt!| t" D} t%|| ||} | S) a; Tries to evaluate expr without introducing guards If unbacked_only == True, then we only do substitutions on unbacked SymInts (leaving regular hinted integers alone). This could result in an expression that still contains backed SymInts, which you could then potentially guard on. Use compute_hint == True if you are trying to compute a non-binding hint for the particular hint values of backed and unbacked SymInts, e.g., if s0 happens to be 3 this run, compute_hint will substitute s0 with 3. z*compute_hint and axioms cannot both be setr!dict[sympy.Expr, sympy.Expr]rfrc,jsdSd_i}t|D]I\}}|tr*|||iJ||dSr)r:rVrr[rBrrv)r! new_itemsrrrs rvresimplify_floor_divz=ShapeEnv._maybe_evaluate_static..resimplify_floor_divs4 05D -IV\\^^,, < <1 55??<$$dmmA&6&6%:;;; MM) $ $ $ $ $rwNc3K|]H}t||j||jvVIdSr)rrrr,)rr rras rvr&z2ShapeEnv._maybe_evaluate_static.. ss   q!!&**1--T^#         rwr)r!rfrfr)rmrvrrr#rr!rrrrrQr.r/rrrrr)rrorrErr!rrisubstr%fsrrIras` @rvrzShapeEnv._maybe_evaluate_statics2  OF O !MNN N}}T>22  ==!788AA3D&d++ % % % % % % >  - - -KEEE P P>**4+<==PLLd&;&;DMM!>A%%y166Q!VVaqA66d99%(1a..II612(.66d99%(1a..II612(.# ;}}%9:: 88J   9AC  :.. K KdilJ77K$(IaL$5MD'4))Q..3;D'3J3J*4004>$.PP19(. )}}%566"4(( 88H   $?A ::ei((D 5>22==djj>W>WXXIjj** C C " g<<D' 2 233t~EE+3D'+B+B$R( $==)9::&x00#>>%)44 (u~ > > I INN5=11!! $$T**$}/E/Ei/P/P$#D rwz7use guarding_hint_or_throw or optimization_hint insteadr) allow_nonerct|j}|jsddlm}t ||rdS||d}||S|rdS|jr||jj sbt dtdfd | tj|d |d 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) rrMNTrEz*propagate_real_tensors size_hint(%s) -> %spropagate_real_tensorsctttjtjddSNrrF)rorrrr.rdrXrJrf)ro unsound_exprsrvr|z$ShapeEnv.size_hint..sP$(JJ&*<&8&8%/%> 1 9q A A A I I K K&&--rwr=propagate_real_tensors: r)rrrr. torch.utils._sympy.singleton_intrNrjrr#rrrr/guard_or_defer_runtime_assertrr_make_data_dependent_error)rror result_exprrNrIrs ` @rv size_hintzShapeEnv.size_hintsf"$''001GHH $! E E E E E E E+|44 t++Kd+KKA} t2 (*33D4WXX #0(KKDdL%0%%%%%    66l;;R;RRLRR('11+tDD Drwsympy.Expr | intrgc$t||iS)z Return a concrete hint for an expression. Returns Python bool (True/False) for boolean expressions (e.g. Eq, Ne), and Python int for integer expressions. )rbrs rvrnzShapeEnv.guarding_hint_or_throws,D$;;;rwcV ||n#t$rYdSwxYwdS)NFT)rnr~rs rvr]zShapeEnv.has_guarding_hintsE   ' ' - - - -*   55 ts  &&c(t||i|S)a Return a concrete integer hint for an expression. This function should be used for non-guarding based optimizations. If you want a hint that you can guard on, use the guarding_hint API instead. This function will hint unbacked symbols using user provided optimization hints. If not provided, fallback will be used along with some heuristics that try to maximize consistency with the shape environment. Special cases: - Complex numbers (containing sympy.I): raises an error since tensor dimensions cannot be complex. - Infinity (int_oo, sympy.oo): returns sys.maxsize. - NaN (sympy.nan): returns the fallback value. )precomputed_replacementsry)rc)rrorys rvr|zShapeEnv.optimization_hints$(' $h    rwexpr_sym_node_id unhinted_exprrr~cng}jD]n}dj|}jd|||jvr||od}d\}} j rd} nd} d}| ddd d tt|pd d |d |ddttjd| z} tdfdt| S)Nrpz-Data dependent variable '%s' allocated at: %sTzDCould not extract specialized integer from data-dependent expressionz,Could not guard on data-dependent expressionzlconsider using data-dependent friendly APIs such as guard_or_false, guard_or_true and statically_known_true.rz (unhinted: z). (Size-like symbols: rnonez) z Caused by: z For more information, run with TORCH_LOGS="dynamic" For extended logs when we create symbols, also add TORCHDYNAMO_EXTENDED_DEBUG_CREATE_SYMBOL="r2z" If you suspect the guard was triggered from C++, add TORCHDYNAMO_EXTENDED_DEBUG_CPP=1 For more debugging help, see https://docs.google.com/document/d/1HSuTTVvYH1pTew89Rtpeu84Ht3nQEFTYhAX3Ypa_xJs/edit?usp=sharing guard_on_data_dependent_errorcttjtjt jddS)NrrF)rorexpr_idr)rrXr.rdrXrJrf)rorrsrvr|z5ShapeEnv._make_data_dependent_error..sVT !%m!4!41#2%-1555==?? !!rwr=)rr@r%rrrr,rUr@rVrrr,r~) rrorrsize_like_symbolsr  stacktracesize_oblivious_result_msgrBrCdescrs ``` rvrz#ShapeEnv._make_data_dependent_errors" , ,A!21!5!!>??J HNN@!Z   DN""!((+++$&!"&"9"9$"?"? ? V DBDK &  q qd q q q q#'99S6G-H-H#I#I#SV q q( q q q q :=#c4K\B]B]9^9^ q q q    + +4555rwr^rValueRangesSLoc | Noner_c|j|j}}|dkr||jvrt|d}||jvrW|jd||||j|<|$|}t||}||j |<n|j|}||z} | |kr|$|}t||}| j|jkr|j|j |_| j|jkr|j|j |_| |j|<|jd|| |j |x} +|j|} | | vr|s| | vrt| d| dSdSdSdS)Nrz"_update_var_to_range %s = %s (new)z%_update_var_to_range %s = %s (update)r) r(r)r,rWrrrrMrr$rrrm) rrr%rr_r(r)rBrtrsrrIs rvrmzShapeEnv._update_var_to_range'sxu 1994>11UA&&B * * * HNN? L L L(*D f %~~'')$55-4D "6 * *#F+C(Cczz?>>++D-dD99G9 ));B=D*6289 ));B=D*628,/!&)FPSTTT'++F33 3A @!&)Azz%@zz,->->1->->??? A @z@@!zrwtgtrc8  jdkrdSjvrdSttjst dtjrtsdSd}j vrj } } || |s/tjdkrtt!j}t#t j|d}|Ήjd|| |d}t+t-|jt1|j} || j }| |st d|d|jvr5ttjrjn=ttjr#jvrj| |s!jd ||dSjvrd d } d } | | s!jd | | dSttjtjfrt?j tCd  fdj"gD]} r j#| <tHj%rNj&dj"dj'jdd t&(d|j<j)vr*j)<xj+dz c_+,-t jddS)zw Adds or updates a replacement for a symbol. Use this instead of `self.replacements[a] = tgt`. NrrFfloordiv_inequalityz2set_replacement: solve for %s in %s == %s gives %sz tgt_bound=z not a subset of src_bound=z:skipped set_replacement %s = %s (%s) [%s not subset of %s]TrzVskipped set_replacement %s = %s (%s) [%s not subset of %s (size-oblivious conditions)]symbolic_shape_specializationc *tdjgDttjt jdrtjnddS)Ncg|] }|j Srr]r;s rvrz?ShapeEnv._set_replacement....sOOO1OOOrwrrF)rrrYreasonrr9)rrrr.rdrXrJrf)rdrrruser_tbsrvr|z+ShapeEnv._set_replacement..s"1ggOO0C0G0G20N0NOOO!#YY!'6)1q999AACC?FO 1':::4 % %rwr=zSpecializing %s to %srSPECIALIZATIONr3zset_replacement %s = %s (%s) %sr).r(rrrjrrrmrsrrYrrTrmrrr'r^rOrrrrWr@r(rCr)r$r,rrrcr)rer/rr=rprint_specializationsrrZrr)rMr9rr)rrdrr tgt_bound src_boundrTrI rat_b_boundb_bound tgt_bound_so src_bound_sorNrs```` @rvruzShapeEnv._set_replacement[s  $#''400 0 0 F  F!U\** J !HtAww!H!HII I  < -c22  F ! ! !)!,I ((--I  % %a 3 3 3%%i00 S9I5J5Ja5O5Oc.//00ehq#..uMMM=HNNL #'"2"21Q4"8"8K)!+"344jAR6S6SG--a$:PQR:STTT $ 0 0 5 5I$--i88,HyHHIHH,DN""z#u|'D'D"""3''''C.. &3$.3H3H""1%%%%%i00 P dn$$#//D/II #//$/GG #,,\:: HNNL$$F cEM5;7 8 8 B%244G /             -11!R88 A AA9@D.v6+ B  +T-@-CA-F-KS/DAAA 2AsCKKK"! D+ + +)-)9)9D #A & **a/** $$&&& ehq#>>>?????rwcb|j||dSr)r*rrrs rv_add_divisiblezShapeEnv._add_divisibles0 4    $$&&&&&rwc|jvr|Sj|}fd|jD}j||\}}|r||dj|S)a Implements a DSU-like algorithm to find the variable that represents a Also handles transitive non-identity replacements. a: b + c c: d IMPORTANT: The output of this method MUST depend only on self.replacements and the input symbol. Do not add dependencies on other mutable state. SymNode.expr uses _replacements_version_counter (which tracks only replacement changes) to cache calls to replace() (and transitively this method), so depending on other state would cause stale cache results. (Note: _set_replacement, may read other fields like var_to_range, but those are side effects that do not affect the returned value.) c<i|]}||Sr)r<)rr rs rvrz"ShapeEnv._find.."s%BBBAq$**Q--BBBrwfind)r(r _xreplaceru)rrdr cur_replacereplacedchangeds` rvr<zShapeEnv._find s& D% % %H"BBBB1ABBB  -a0::;GG'  7  ! !!Xv 6 6 6 ##rwct|tjr!|jD]}|dSt|tjsdSt|tjrdSt|j}t|dkrtd|t|dkrdSdfd }t||d }|j }|j }|t|tjsdS|t"s |t&|t&}t|dkr t+d |Drt,dfd }|||r+||dn|||r+||dnt3||dd} | t5dtj| dDrZ| d} tt9| dk} | r|d| dn#t,$rYnwxYwt;t=|t"} t3|| d} | !| ddkr| n#t,$rYnwxYwdS)z The relational guard is guarded to be true. Use this information to simplify shapes (i.e. a == b or a % 5 == 0) Nrz3The expression should not be static by this point: rrrftuple[int, int, str]cf|jvo#tdj|D}j|}|t |t r t j}n6t|tj rt|}n t j}|j }|rdnd||fS)Nc3>K|]}|VdSr)rpr;s rvr&zHShapeEnv._maybe_guard_rel.._smart_symbol_sort..JsEJJ%&  JJJJJJrwrr) rr0rrrjrNr"rrRrSrrtrZ)rhas_only_ephemeral_sourcesrurrZrs rv_smart_symbol_sortz5ShapeEnv._maybe_guard_rel.._smart_symbol_sortIs)*d.A)A*cJJ*.*=a*@JJJGG &)--a00D|z$ ==| {49-- #4yy{6D3:AAD$G GrwT)rrc3,K|]}|jdkVdSrrors rvr&z,ShapeEnv._maybe_guard_rel..ks944'(AIN444444rwrrrrrct|tjrBt|rt |jsdSt |tjrdSdSrp) rjrrr<rAr=rRrSrj)rrrs rv trivial_solvez0ShapeEnv._maybe_guard_rel..trivial_solvesm!#u|44(0("C!5##( $(4)#tz::(#'4!5rw trivial_lhs trivial_rhsFrc3$K|] }|jV dSr)rV)rrs rvr&z,ShapeEnv._maybe_guard_rel..s5--)* ------rwrr)rrrfr)rrrrrfrr) rjrrr_maybe_guard_relrrrVrrrmrrr_refine_rangesrr[rGr rBr)rrrur<rOr0preorder_traversalr<r'r^r) rror7freerrrfloor_div_atomsrrIrokmod_exprs ` rvrzShapeEnv._maybe_guard_rel(s dEI & & y + +%%c**** FD%),,  F dEH % %  FD%&& t99>> LdLL  t99q== F  H H H H H H*d 2DAAAhh D!!!$))  Fxx}}@ 6 "%))H"5"5";";CIIhIgnored guard %s == %s, this could result in accuracy problemsr3) r2rrKr6r2rrrgetEffectiveLevelr WARNING)rrors rv _check_frozenzShapeEnv._check_frozens  $ %]T]]|]]  ;  L1 2 2 2a 7 2 2 2 &n(,%@%@,%@%@ !     HHP0022W_D        rwtypes.FrameType | Nonecztj}|%|jjt vr|S|j}|%|Sr)rrrrrCr)rrs rv_get_user_framezShapeEnv._get_user_framesH$&&|'/B/D/DDD LE rwrA framework_loctuple[SLoc, str]c|}|N|} |/tj|jj|j|jj}~n#~wxYwd}tj}|rpt|dz }|dkrA||j tvr&|dz}|dkr||j tv&t||d}d}|r,|r*dd tj|z}|rOtjrCt#jd} |dd | zz }n|r|d z }t)|||fS) NrrT)linerpzM User Stack (most recent call last): (snipped, see stack below for prefix) )rz C++ stack trace: z? For C++ stack trace, run with TORCHDYNAMO_EXTENDED_DEBUG_CPP=1)r traceback FrameSummaryrrrco_namer)rerfilenamerCrYr@ format_listrextended_debug_cpprXrJrr') rrArflocrmaybe_user_locrrrC cpp_stacks rvr@zShapeEnv._get_stack_summarys5B <((**E $$1 0 ,D EE  .00  Cg,,"C''gcl37J7L7LLLq''gcl37J7L7LLL)'#,TBBBN   >'')/8899:   1 )1d;;;I !7"'')BRBRBTBT:U:U!U U     R  D.))+<<.go>sV!U\** ABqEEEEABqEEEE1##%%&&&=QVVXX== xxzz=='('7'7'9'9=== A:;; 1OOA1vv.. D///040CA0Fq0I0N c!ff-1vv 4rwrrc&g|] }|Srr)r flat_localrs rvrz/ShapeEnv._find_frame_locals..Zs....'1BBzNN...rwrpc$g|] }|d Srr)rrindents rvrz/ShapeEnv._find_frame_locals..ds!:::cS\:::rw)rr rj)rrrfr)_find_user_code_framerrrrVdisBytecodergetsourcelinesr starts_linerrrjargvalrf_localsr tree_flattenrlstripr@r)r frame_localsr instructionsco_linesrstartendrrinstr last_linenolineno flat_localslocs frame_locrrrs` @@@rv_find_frame_localszShapeEnv._find_frame_localssu (* (* +,, ,E  \-;;$&& &CL6677 "1%,??&*sC!,//  HAu ,'en$$} =CK$&& &        ,n !%#'/2  E++8!+v66 %,,, 1O1O$1%.2NOOPQR ....5@... U\* /+/F2JJK '$&& &T!WDGNN$4$4 5 55GG::::T:::;;AACC  ,     rwr] forcing_specc tdfdtdfdjtjryt }tjduo|tjk} |\}}d}|sd|d}j d |snd ||||| dSdS) N guard_addedc tjtjdtjdfdjDtdS)NrcHi|]\}}|jvt||Srrr)rrrr]s rvrz9ShapeEnv._log_guard....rs<&&&1AN**FFA***rw)ror/ expr_node_idr9rsymbol_to_sourcesr) rrXr.r;r<r'rrr)r]r/rsrvr|z%ShapeEnv._log_guard..lsA $ 6(7::#7::&&&& $ 2 8 8 : :&&& !'t'>'>'@'@ A A ! !rwr=guard_added_fastcttjtjtjt jddS)NrrF)ror9r)rr.rdr)rerXrJrf)r]srvr|z%ShapeEnv._log_guard..|s\A(78T8V8VWW#2%-1555==??!!rwrpzA, for more info run with TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED=""z%s %s [guard added] %s%s%sz (forcing_spec)r3) r,r/rr r INFOrrextended_debug_guard_addedr@r) rr/r]rstr_grArBrCrxs ``` rv _log_guardzShapeEnv._log_guardisV              8  . . FFE1=?V>> '+&=&=h&G&G #D# O H?DHHH  HMM,*J60J0J0J!#        rwrXr:rc|t||_||j|j|j||S)zW Given a SymNode, evaluates sym_node.expr, adding guards if necessary. )r)r:rXrrorur#)rr)rrs rvrzShapeEnv.evaluate_sym_nodesE"$H!! M M   ) "   rwc|}|tdttj|j}t jdkrddlm }|||j d}n |j dz}t jdkr||j d vr|d z }tj jd }||d z|d zt!|z}d |D}||kS) Nzframe must not be None)r r) bisect_leftc|jSr)rrs rvr|z,ShapeEnv._is_python_assert..s!(rwrr)r )TO_BOOL COMPARE_OPrFcg|] }|j Sr)opname)rinsts rvrz.ShapeEnv._is_python_assert..s777TT[777rw)rrmrVrget_instructionsrr" version_infobisectr%f_lastir+rpr-symbolic_convertget_assert_bytecode_sequencer)rrinstsr%r assert_insts cur_instss rv_is_python_assertzShapeEnv._is_python_asserts$$&& = !9:: :S)%,7788  w & & * * * * * *+eU]8J8JKKKCC-1$C  w & &Sz $===q}5RR   #'C!Gc,.?.?$??@ 77Y777 L((rwr_unsound_resultctdtdfdtdfddS)Nz.propagate_real_tensors evaluate_expr(%s) -> %srctttjtjddSrr)r_r7srvr|z7ShapeEnv._log_real_tensor_propagation..sPY~..#2%-1555==??!!rwr=!propagate_real_tensors_provenancec "ttjtjdtjdfdjDtdS)NrcHi|]\}}|jvt||Srr)rrrr_s rvrzKShapeEnv._log_real_tensor_propagation....s=&&&1I222FFA222rw)rorrr9rrr) rrXr.r;r<r'rrr)r_rr7srvr|z7ShapeEnv._log_real_tensor_propagation..sY~.. $ 6(7::#7::&&&& $ 2 8 8 : :&&& !'t'>'>'@'@ A A ! !rw)rrr/r,)rr_r7s```rv_log_real_tensor_propagationz%ShapeEnv._log_real_tensor_propagations <      $   /            rwrint | bool | float | Noner#c jt}||||||||S)z Given an expression, evaluates it, adding guards if necessary When fallback_value is not None the function return fallback_value instead of failing with data dependent error. )rr_inner_evaluate_expr)rr_rur#rrrsuppress_guards_tlss rvrzShapeEnv.evaluate_exprsC ';;==((          rwr)save_tracked_fakesrZrc |||||||S#t$r:}t|trn|jd||||d}~wwxYw)Nr>zKfailed during evaluate_expr(%s, hint=%s, size_oblivious=%s, forcing_spec=%s)_evaluate_exprrrjr~rr) rr_rur#rrrrr%s rvrAzShapeEnv._inner_evaluate_expr s &&) '    !899   a"   s A!5AA! assumed_valuecr|d\}}td||||dS)NTzfcould not evaluate %s due to data dependency, it was assumed to be %s with no runtime assertions %s %s)r@rr)rrdrFrBrs rv_log_suppressed_ddezShapeEnv._log_suppressed_dde7 sH--d33 e  t         rwbool | int | float | Nonec ttjjjtjjjfrSt jdfd }d}d} jrB|? s*|s'tdj Ds||} | tj ur% tj|f\}} n| tjurI t"j|f\} } tj| f\}} nI t"j|| f\} } tj| f\}} |t)d| r|d} jrxjdYtt2rkrt)dn)tjst)dS}tjjjjt>j kr!|}||Stjjjj}b|d kr\|Z|t>j kr"||S#||}||ur"||S$|| }|Pjd |rd d n|||s(tJj&r|krt)|d|Sd}d} |j j'(ks-$|d}|t)d|j j'(ksd}|s|"||S|s\j)rU*j)*j'x}j s+|d}|} d}|s+j,r$-rtj } d}d}|s5.|*j'|j/n|}| |} 0|| tJj1rOtt2r:t|tjtj2frtj3|}| tj urtitj|}n8| tjurtj3|}ntj|| }|r6|dd| | S s7d||8|tj9:r!j;r6|dnty|=| }j>?|j@AtCD|n7d||n&#t$r| rF|wxYw s||j D]}}jG|xxdz cc<|sdtJjHXjG|tJjHkr=jIdtJjH|J|d~| S)NrfrcT tjS#t$rd}||cYSwxYwtjS)NTr)rrrnr~r)rIrur_rs rvcompute_concrete_valz5ShapeEnv._evaluate_expr..compute_concrete_valT s|  =)D)DY)O)OPPP2 33ID3QQA} }T***s&,%AAFc3JK|]}t|tjVdSr)rRrSrjr;s rvr&z*ShapeEnv._evaluate_expr..| s.VV!q$*55VVVVVVrwnode must not be Nonezeval %s [trivial]ryrrz eval %s == %s [statically known]zsize_oblivious(rnTrnew_expr must not be Nonerrrr!r>zevaluate_expr: zeval [guard suppressed]rz6symbol_guard_limit_before_specialize=%s exceeded on %s)rfr)Krjrrerfrgrhrcacherrrrr\rrp_assertr]rnot_rrmrr.rrrrrr&r'r3aggressive_guard_free_semanticsr4SKIP_RANGE_ANALYSISr^rHrbrrrrrr#rr=rr6rrXr/inject_EVALUATE_EXPR_flip_equality_TESTING_ONLYrrrrrr!rcompiler is_exportingrr&rMrBrUr!rrrQrvrrr7$symbol_guard_limit_before_specializerr)rr_rur#rrrrLrqrrrreqlrro fast_resultaggressive_level range_result static_exprtransmute_into_runtime_assertrrr7r]r s``` rvrEzShapeEnv._evaluate_exprA s   [ ,ek.A.N O      + + + + + + +  +@  0 1#--//$"$VVy?UVVVVV$&0/11Luz))";;EMG:VV ee,,66x}wjQQQ";;EMC6RR ee66K'>>#!$--K$,,"0I1I1I41I1I"J"JJ- %x 488K"0I1I1I41I1I"J"JJ  D %-M)=>>#>>tDD *&& %-M | 01 4 49S#'>'RRR,,YGGG))$(#B#B4#X#XL#~5500NKKK''55^6K&6*,6)6666+'I4I(#d**, -G-G-G-GHHH"",1 )L%)?)D)D)F)FFF 66t46PP#()DEEE -1G1L1L1N1NNNB.."<00NKKK--  " ? "/8.@.@ $ C//&ht'=>>?N' "99)^TTT8<5'5 !"$"4"9O9O9Q9Q"',z 8<5!"== MM$*@AA -1-C>$D#3355   t\ 2 2 2F 'tT** 'teh%9:: ' yuz))t,,,,IdOOHT<00, $22O)OOOO$#,,.. Y EEE%%a(((N//11VHV66q:WI:W:WXXXX '4>>++NEK&&u---K&&tD,A,A$--PQBRBR,S,S'T'TUUUU 91<XXX    +$$T***   ((** A AAA-a000A5000) A"GS 5a8 EFF T"G **14*@@@s=+A>[*A[.A [;1[-A([B[%F=[#D$[#[+c|jD]}||jD] }|D]}|j!dS)z Break reference cycles. This destroys the stacks. If you really want to keep them, we just need some way to break references on code objects. N)r%rcleanupr0r)rr rar`s rvrazShapeEnv.cleanupg!s"))++  A IIKKKK07799 # #C # #  """" # # #rwcd}t|tjr|jdkr|j}n,t|tjr|jdkr|j}t|tjrJt|tj r0|j |}|j t kr|j tkrdSdS)aCheck if we should skip _maybe_evaluate_static for the given expression. Skips static evaluation for single unbacked symbol >= 0 (or 0 <= symbol) when the symbol has unknown range [-int_oo, int_oo]. This pattern is common during tracing and doesn't benefit from static evaluation since the symbol has no constraints. Note that the first time this is called value range will be updated and next time it's called (if any) we would call _maybe_evaluate_static and it would return True. NrTF)rjr GreaterThanrrLessThanrrRrSr5rr(rJr))rro unbacked_symr%s rv_should_skip_static_evalz!ShapeEnv._should_skip_static_evalt!s dE- . . $48q==8LL en - - $$(a--8L lEL 1 1 n $+7 7  "<0BxF7""rx6'9'9turw)rCc |}||}|t|S||r|}nj||}|+|jd||t|S||d}|t d|js9|j|j kr| ||S|j rb|`| sL|tj|f\}} |t d| r||| sv|d|d |jrtd |||t*j|||}t1|}t3jd } t7||| } dd} t9d|jD| } | r| dnd}|j|g| |j !tE|#|$||xj%d z c_%|&n|d|d dS)a Adds a guard that orig_expr is True if we can or fall back to adding an assert that is checked at runtime. Args: orig_expr (sympy.Expr): Boolean expression to assert is true msg (str): Message to display on assertion failure fx_node (Optional, torch.fx.Node): node in ``self.graph`` corresponding to the expression, if applicable Nz*runtime_assert %s == %s [statically known]TrOrPr"rNruntime_assertFr>z&runtime_asserts_frozen but then got %srrFr rrftuple[int, str]ctjtjfD]U}t||rCt |jt t|dt|fcSVtd|)Nzexpected unbacked symbol, got ) rSr5r6rRrtrZrrQrm)r  symbol_types rvunbacked_symbol_sort_keyzHShapeEnv.guard_or_defer_runtime_assert..unbacked_symbol_sort_key!s$($5t7J#KK%a55s:k+B'C'C'E'E FGG&{3  %%Ia%I%IJJJrwc3fK|],}t|tjtjf(|V-dSrr:r;s rvr&z9ShapeEnv.guard_or_defer_runtime_assert..!sQ%a$*;T=P)QRRrwrrSz!runtime_assert [guard suppressed])r rrfri)'r^rrrfrrrrmrrrrrrrrrprRrr!r3rrr\rrrXrJrrr0 setdefaultrUr!rrrQrvr1r)rr_rr#ror[rr^rqrrr`rlcandsixs rvrz&ShapeEnv.guard_or_defer_runtime_assert!sL 66t<<  " $$ $  ( ( . . BHH55d;;K&@)[K(((224t2LLH$%@AAA@ A%)?)D)D)F)FFF%%h%@@ @  0 1#--//$77 zRRKD%|$%<=== 1**4000((**-  OO,ieO L L L* J BDIII   tUZ 0 0 0  ! !$ ' ' 'I)$//D%-1555EtS%00B K K K K!. - E$-rB  ) 4 4R < < C CB G G G K  tD$9$9$--:M:M$N$NOO P P P  - - 2 - -  ( ( * * * * OO3YU    trwc||}|jD]6}t|tjst dt |t|j|dtrkt||}||j r |dj s|\}}|j |}|j |j}}t||j } || j kr`t|tjtjtjfr/| j t't|tjz}|| jkr`t|tjtjtjfr/| jt't|tjz }|t-||kr||t-|||j |r'|||j |j d|j8dS)Nrrrange_refined_to_singleton)rvrrjrrrmrsrrrNrOrVrr(r)rTrrrrtrrrWrmrkrurr) rrorrIr_exprrr%r(r)rhs_vrs rvrzShapeEnv._refine_ranges"s+}}T""': 6: 6Ffel33 S$%Q4<<%Q%QRRR$044VTBBLQQ $''Ay!2yqtyKFC"6*B8RX5E d&788F $$58UX6**$  s:feh+G+G'H'HH $$58UX6**$ s:feh+G+G'H'HH[....  % %fk%.G.G H H H (5577 %%%f-30  ' 3 3 5 5 5 5u: 6: 6rw)rr rrc"t||}|j|tj}||||j|x}|kr)t d||j|jdSdS)Nz"constrain_symbol_range %s [%s, %s]) rWrrrKrmrrr(r))rr rrupd_vrold_vrnew_vrs rvrzShapeEnv.constrain_symbol_range@"s \<88"&&q+*=*?*?@@ !!!V,,,'* *Fv 5 5 HH4av|      6 5rw)r rr r rrrfr)rrrrrrrrrrrrrrrrrrrrrrrfrrfrr)rNr(rOrOrfr)rrrfr)rfr rrfr)rrrrrrfr)rrrrvrfr)rrrrrrfr)rdrrrtrfrNN)rdrrrzrrzrfr)rdrrrtrrtrfr)rdr"rTr"rfrrTrrrfrrr)rNr(rfrB)rrrsrsrfrrU)rrrrrfr)rrrsrsrfr)rqrrfr)rqrrfr)rfr)rfr)rrrNr(rRrrfrr) rrrNr(rRrrrrfr)rrKrNr(rRrmrfr)rrrWrrrarNr(rRrmrrrfr)rrrrrrarrrNr(rRrmrrrfr)rNr(rrrrrrrirrkrr rrrRrrfr)rRrrurrNrrfra)rRrrurrNrrfr`)rRrrrtrfr) rYrtrNr(r rr(rzrfra)rRrrfr ) r/rrrr%r$rNrr)r0rfr)rfr!)rNrrfr")rrrfrr)rSr"rTrrfr)rfr ) rr[rNr(r rr rcrRrmrfr)rr rNr(r rr rcrrrrrrRrmrfr)rorrrtrfr)rfr}r,)rNr(rrrfr)rrrrrfr)rrrrrrrBrrrrrrrrr rrrrrfr)rrrBrr rrrfr)rrrfr)rrrfrz)rrrr'rfrr)rrrr,r rrrfrr)r.r/rfr0)rrrr,rfr)rfr:r)r>rrrfr)rorrrrrfr$r)rjrDrErrrfrF)r%rrfrP)rrrfrr)rorrfrr)rorrfr[)rorryr[rfr[)rorrrrrErrrrrr!rcrrdrfr[rorrfr)rorrrrrfr)rorrrrrfr[)rorrfrg)rorryrzrfrt)rorrrrrzrfr~) rrr%r$rrr_rrrfr)rdrrrrrrfr)rorrfr)rdrrfr)rrrrfr$)rfr$rorrfr)rorrrrfrrfr)FN)rArrrrrfr)rrrfr')rrrfrt)rfr)r/rr]rrrrrfr)r)r:rrrrrrfr)r_rr7rrfr)NNFN)r_rrur?r#rrrrrrrrrrfr)r_rrur?r#rrrrrrrrrrrrrfr)rdr rFrrrfr)r_rrurIr#rrrrrrrrrrfrr)r_rrrr#rrfrr)r rrrtrrtrfr)rrrrrpropertyrrrrrrrrVrdrlrnrqr6rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr&rr+r.rDrHrrrXrZrrr*rr|r FutureWarningr4rrrrrrr#r&r+rr6rr=rArTrrOrrQrXrZr^rbrrQrprvrrnr]r|rrmrurr<rrlrQrrrr@rMrirr!rXrrr6r=rrArHrErarfrrrrrwrvrrs-1*. 888888D&*/3 */%)#'+/=B$I______B 222X2<<<X<666X6111X1(((X(IIIXI+ + + ^+ Z=V=V=V=V~KKKK($$$$&&&^&CCCCBBBBJJJJ,    IM*"&9&9&9&9P44445555^ + + + +....11111111////&&&&====@,,,,8(((( ====666\6####""""&&&&222^2"     ''''&    15 GGGGG\48       R4804t@t@t@t@t@t@l4804IGIGIGIGIGIGV9999v !% ++++++Z !% ''''''R6666 &*      *7777!%#' # # # # # J""""4     299991111$!!!!4 #-/(,37      : #-/(, $+037vvvvvp ::::ZA&&& X &ZI555 5FFFF    ,XXXX/?.> l +/:>8<!"!=lllllld+/" 2........KKKK#          6666p          8=/////$/3"3333Z3<Yt__&$&$&$_&$P    4(,& $"$-1SWXXXXXZXtZ4'''Z'LLLLZL^ZAYs^^7<+++++^  +ZYs^^<<<^<Ys^^^>B     :(, 969696969696~+/ 2@ $ 2@2@2@2@2@2@hk@k@k@k@Z''''$$$Z$4Ys^^@@@^@H27***** )))) # # #Z #4CG)=)=)=)=)=XI I I I V0000j%)(((( %&*      &")")")")H! ! ! ! L+/(,$&*  #      6Ys^^dIII'+JI^@    +/(,$&* d#ddddddL # # # #.Ys^^d333QUhhhh43^hh=6=6=6=6~Yt      rwcNt|to|jjjSr)rjr"rqror.rrs rv_is_intrN"s dF # # @ (@@rwrdc4t|do||jvS)N_dynamo_dynamic_indices)rr)rrs rv_is_dim_dynamicrS"s 1/ 0 0 SQ!:S5SSrwc eZdZdfd ZxZS)PropagateUnbackedSymIntsrrrfrcddlm}t|}|}|t dt |j|||S)z] Run an FX node, propagating unbacked Symbol bindings to the new fake tensor r)detect_fake_modeNzfake_mode must not be None) torch._guardsrrrun_nodermrrl)rrrrrrs rvrz!PropagateUnbackedSymInts.run_nodeX"sk 322222!!!$$$$&&   !=>> > +Q777 rw)rrrfr)rrrrrrs@rvrrW"s=          rwrrctj}|o|jjt jtjtt jj zsn |j }|o|Sr) rrrr startswithr:r;r<rrpsepr)rs rvrrf"sr  " "E  |'22 GOOGOE22 3 3bgk A        Lrwr%rrtypes.FrameTypec$tj|jj|j|jj}|jd}|ddtj |g zz }|f|_dS)Nrz( The following call raised this error: rp) rrrrrrrr@ StackSummary from_listr)r%r frame_summaryrs rv_blame_user_coderq"s*    M &)C 8277((-99@@BB<< CVAFFFrwc,eZdZdZd fd Zd d ZxZS) _PythonMsgPrinterz Util printer that replaces sympy symbols with their source-level names and renders sympy relational operators (e.g., Eq, Ne, Ge, Le) inline (i.e., as ==, !=, >, <). src_mapdict[str, list[str]]rfrcVt||_dSr)rrr)rrrs rvrz_PythonMsgPrinter.__init__"s$  rwrRrrc2|j|jdSr)rrZr-s rvrz_PythonMsgPrinter._print_Symbol"s|CH%a((rw)rrrfr)rRrrfrr1rs@rvrr~"s[ ))))))))rwrrdefaultdict[str, list[str]]cV|j}dfd|jD}|rtd|dSt }|jd}|dz }|tj |}d||dd|dg}t|D]\}} |d |d zd | z }dfd td |jDD} |d| d|dz }|f|_dS)av Enhances a GuardOnDataDependentSymNode error with suggested fixes using torch._check. This function analyzes the condition that caused the data-dependent error and generates user-friendly suggestions for fixing it by adding appropriate torch._check calls. It handles special cases like non-negative checks with specific recommendations. Args: e: The GuardOnDataDependentSymNode error to enhance with suggestions src_map: A mapping from symbol names to their corresponding source-level variable names Returns: None. Modifies the error message in-place by updating e.args[0]. rc38K|]}|jv |jVdSrr]rr rs rvr&z(_suggest_torch_checks.."s1PP!&:O:OQV:O:O:O:OPPrwz.Unable to find user code corresponding to {%s}NrzG To fix the error, insert one of the following checks before this call:z torch._check(rnrrrc3ZK|]%}d|dd|V&dS)`z` with rN)r@rs rvr&z(_suggest_torch_checks.."sW  0A//fkk'!*--//rwc3$K|] }|jV dSrr]r;s rvr&z(_suggest_torch_checks.."s$::1::::::rwz3 (These suggested fixes were derived by replacing z in z and its negation.)) rr@rrrrrrrrrr) r%rrdiffrr not_cond_strsuggested_fixesrfix src_mappeds ` rv_suggest_torch_checksr"s$ 6D 99PPPPT%6PPP P PD  DdKKK((G &)C UUC??59T??33L 1--000' '''O O,,%%3 $a!e$$s$$$::(9:::::J l: l lSW l l llCVAFFFrwc t}|t||tt}|jD]G\}} t j|}n9#t$r,t dt||YQwxYw|D]\}}|t j |z}t|tjr3|t!|jj|it|tjrlt+|jD]W\} } t| tjr8|t!| jj|d| dXIt|jt0jjjrt9||dSdSdS)z Given a raised data-dependent error, add the following to the error message: 1. the closest user code location that raised the error; 2. suggested fixes for the error in terms of live variables at that location. NzQpytree.tree_leaves_with_path failed for value of type {%s} in local variable {%s}z.shape[r)rrr rVrrrtree_leaves_with_pathrrrrskeystrrjrpr"rrqrorUrZrrOrrrerfBooleanr) r%rrvarrrr;leafrZrrXs rv2_suggest_fixes_for_data_dependent_error_non_strictr"s " # #E E"""d##,,.. U UHC (.(DS(I(I%%    gII   4 U U dV]4000dEL11UC //077====el33U"+DJ"7"7UU3%c5<88U#C $6$67>>$?S?Sq?S?S?STTT U afek19 : : . !!W - - - - -;8 . .sA++3B! B!c#K|jdi}d|D}||jd< dV||jd<dS#||jd<wxYw)a Temporarily modifies unbacked_bindings in a node's metadata by removing the first element of each path, which corresponds to an effect token. This is used when processing nodes that have effect tokens as the first element in their unbacked_bindings paths. The context manager ensures that the original bindings are restored after the operation is complete. Args: node: The FX node whose unbacked_bindings will be temporarily modified Yields: None rc2i|]\}}||r |ddn|Srr)rrr;s rvrz:_remove_effect_token_unbacked_bindings.."s/VVVgaA41tABBxxTVVVrwN)rrr)rq old_bindings new_bindingss rv&_remove_effect_token_unbacked_bindingsr"s$9==!4b99LWVASASAUAUVVVL%1DI!"6 )5 %&&& %&5555s A A#r)cp|j}|td|j}||jvr |j|S|S)Nz/shape_env is required for _get_placeholder_expr)rlrmrr)r)rlrs rv_get_placeholder_exprr #sG"INOOO ^F ---+F33 Mrw)rdrerfrgr)rdrxryrzrfrt)rrrfr)rrrfr)rrzrfr)rfr)rJrKrfrr)rOrPrfrQ)rdrYrfrr)rdrarfrr)rdr`rfrr)rdr_rfrr)rdrirfrr)rornrfrr)rsrrtrrfr)rlrrrrfr)rlrrrrrrfr)rqrrfrr)rorrfr)TN) rrrrrrrrrrfr)rorrfrr~)r r rfr)rrrfr)rrrfr)rrrfr!)rrrfrr)rrrfrr)rrrfr!)rrr=r!rfr!)rqrrfrB)rDrErfrF)NNNF)rdrr;rqrrrsrlrrtrurvrrrfrwr) rlrrrrrsrrrrfr)rdr_rrrrfrr)rr rfr)rqr:rrrrfrr)rr_rfrr)rr_rr_rfr_)rrrrrfr_)rdrrfr)rdr"rfr)rdr"rrarfrr{)rdr"rrzrrzrfr)rdrrTrrfrr)rdr_rrtrfrr)rdrarfrt)rdr`rfrb)rrrfr)rrrfr)rrrrZr rrrfrr)rrrrZrfr)rRrrfrS)rorrfrWr)rrrfr)rrrfrr})rIrrfr) rorrrrrrrrrrfr)rfr)rrrWrrfrt)rrrWrrfrr)rrrfr)rrrfr)rrtrfrt)rArrrzrfrryr|rz)rlrrfr)rorrfr)rrKrrtrfrrr)r%rrrrfr)r%r~rrrfr)r%r~rfr)rqrrfr)r)r:rfr(? __future__rrrtorch._prims_commonrrrrr r5rrr?rrrr rrr:rr" threadingrrr collections.abcr r r r r contextlibrr dataclassesrrrenumrtypingrrrrrrrrrtyping_extensionsrrrptorch.fxtorch.fx.tracebackr&rtorch.utils._pytreer\_pytreerr r!r"torch._C._functorchr#r$r%rr&r'r(r)"torch._library.fake_class_registryr*torch._library.opaque_objectr+rr,r-r.r/torch._opaque_baser0r r1torch._utils_internalr2torch.fx.experimentalr3rtorch.fx.experimental._configr4torch.fx.experimental.recordingr5r6r7r8r9torch.fx.experimental.sym_noder:r; torch.typesr<torch.utils._ordered_setr=torch.utils._python_dispatchr>torch.utils._sympy.functionsr?r@rArBrCrDrErFrGrHrItorch.utils._sympy.numbersrJtorch.utils._sympy.printersrKrLrrNtorch.utils._sympy.solverOtorch.utils._sympy.symbolrPrQrRrStorch.utils._sympy.value_rangesrTrUrVrWtorch.utils._tracebackrXrYtypesrZrr\rr^r_r`rarV InputListDimList getLoggerrr#torch.fx.experimental._size_hintingrbrcrnr|rr~rr_opsrr__all__rrrrrrrrrrrrrCrIrrtrNrrbrrrYr]rrrrrrrrrrrrrrrrrrrrr rrrr<rArrJrrrYrerkrrrrrrrrrrrrrrrrrrrrrrrr rrrrr#r.rcr1rVrYr`rrrerfrrrrrIndicatorTypesrrrrrrrrrrVrrrrrABCrr rrr!r$r&r+r3localrrrrrrrrrrr Interpreterrrrrrrrrrrwrvrs""""""" <<<<<<<<<<     ,,,,,,,,LLLLLLLLLLLLLL????????0000000000                      43333333 )))))))))$$$$$$$$$,+++++++++VVVVVVVVVVBBBBBBBBBBBB??????888888VVVVVVVVVVVV))))))666666000000333333AAAAAA=<<<<<<<$$$$$$//////FFFFFF                          .-----AAAAAAAA999999......SSSSSSSSSSSS CBBBBBBBELLL999999888888DDDDDDDDDD  g!!     4      ,     L   YYYYY,YYY z~- - - `&!,8 7777 WT]] ')UZu{ C CD    ####P 4++++\     |   ,,,,#########L5>1EMACG%ORVVVVVV    *(.DDDD2 S    "IIII:TTTT&L5s):#;;;;;;F:F:F:F:Z@....<"& 4C4C4C4C4Cn+'+'+'+'\....bBBBB  X#%-4u{BU\Q+X6F-GG GGGG5Y5Y5Y5Yp<<<<,IIII>OOOO    4    0 $d### $ $ $ $ $ $ $$# $ $d###3333333$#3 $d###'''''''$#' $d###+++++++$#+ $d###!!!!!!!$#!!%(, E E E E E V(, aaaaar6&    60     O O O O    99996(%(%(%(%V I I I I:>FFFFF&FJ)=)=)=)=)=)=X%%%%f                  LLLLGGGGDH      DDDD f $d###$# $d###FFFFFZFF$#F8 $d###99999j99$#96')@@4G  $d###gCgCgCgCgCgCgC$#gCT * * * *  $d###       $#  $d###O$#i genn $d###11111S0A11$#1T $dD111999996sCx@99219< $d###)))))5))$#) &""""45GGGGB5555p 3(* 4a/a/a/a/H---- OOOO ((((V....4QQQQ*Q(H    2655555p $d### 1 1 1 1 1 1 1$# 1     ]   _ _ _ _ _ _ _ _ D000000-000f Z       /    ...... ...4 $d###$#  $d###11111.11$#1KKKKK6KKK 33333-3334h h h h h h h h Vio@@@@  1 1 1 1 $d###       $#  **** :::::::: MMMMMMMMMMMMMMMM`ZAAAA TTTT     ux3        ) ) ) ) ) ) ) )++++\(.(.(.(.V6666Drw