o j9:j"@sUddlmZ ddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z m Z ddl m Z mZmZddlZddlmmZddlmZmZmZmZmZmZmZmZddlmZeryddlmZddl m Z ddl!Z!dd l"m#Z#e$e%Z&ej'e%d Z(e)Z*d e+d <e,e-Be.BdBZ/gd Z0ddl1m2Z3edddZ4edddZ4edddZ4edddZ4dddZ4GdddZ5Gd d!d!Z6Gd"d#d#e6e.Z7id$ej8d%ej9d&ej:d'ej;d(ej;d)ej<d*ej=d+ej>d,ej?d-ej@d.ejAd/ejBd0d1d2d3ejCd4ejDd5ejEd6ejFid7ejGd8ejHd9ejId:ejJd;ejJdejLd?ejMd@ejNdAejOdBedCedDedEedFedGejPdHejPiZQhdIZRddMdNZSdOZTeTD]&ZUdPeUZVdQeVZWeXe5eVeSeUeYeeWeQeV<eR:eVe0ZeVqpd0hZ[eRe[BZ\hdRZ]hdSZ^d*hZ_e]e_BZ`hdTZad'd:hZbd'd:dUdVZchdWZdeTD] ZUdPeUZVed:eVqhdXZehdYZfdd]d^Zgdd_d`ZhddadbZiddcddZjddedfZkddgdhZlddidjZmddkdlZnddmdnZoddodpZpddudvZq w wddd~dZrdddZsdddZtdddZuid&ej:dAejOd7ejGd6ejd>ekd=eld'emd(esd:end;etdd?Zdd@dAZddCdDZddEdFZddGdHZddIdJZddKdLZddMdNZdddPdQZddRdSZ ddTdUZ!ddVdWZ"ddXdYZ#ddZd[Z$dd\d]Z%dd^d_Z&dd`daZ'ddbdcZ(ddddeZ)ddfdgZ*ddhdiZ+ddjdkZ,ddldmZ-ddndoZ.ddpdqZ/ddrdsZ0ddtduZ1ddvdwZ2ddxdyZ3ddzd{Z4dd|d}Z5dd~dZ6dddZ7dddZ8dddZ9dddZ:dddZ;dddZdddZ?dddZ@dddZAdddZBdddZCdddZDdddZEdddZFdddZGdddZHdddZIdddZJdddZKdddZLdddZMdddZNddddZOdddZPdddZQdddZRdddÄZSdddńZTdddDŽZUdddɄZVddd˄ZWddd̈́ZXdddτZYdddфZZdddӄZ[dS)rz This is a type erased SymInt/SymFloat which we use to do actual operations. End users don't touch this. Magic methods are NOT defined on this object. Fr,_optimized_summationNexprr shape_envShapeEnv | Nonepytyper+hintHintType | objectconstantint | float | bool | Nonefx_nodeoptimized_summationrNonec s|_|_|_|_d_d_d fdd }|tur d}n>|dur[t||us>t|t|us>t d|dt|jrZjj rZ|} || krZt |d| d j d n|}|_ |_ jojjj } | on|_dS) Nr&HintType | SymInt | SymFloat | SymBoolcsbddlm}|jr dSjdurtdjjjdd}|dur/t|ts-|n|}|S)Nr)has_free_unbacked_symbolsz%shape_env is required to compute hintT) compute_hint) %torch.fx.experimental.symbolic_shapesr=r0r1 RuntimeError_maybe_evaluate_static isinstanceSymTypesr3)r=r4selfr"r$r>s   z&SymNode.__init__..compute_hintzCannot create SymNode of type z with incompatible hint of type z != z (for )rr<)_exprr1r3r/ _expr_ver _expr_cacherr+r%AssertionError_translation_validation_enabledr0_hintr6r8) rEr0r1r3r4r6r8r9r> computed_hinttx_validation_enr"rDr$__init__hs:  zSymNode.__init__rcCst|j||j|j|j|jSr!)rrHr3rMr6r8)rEr1r"r"r$with_shape_envszSymNode.with_shape_envothercCs<|j|jko|j|jko|j|jko|j|jko|j|jkSr!)rHr3rMr6r8rErRr"r"r$ _value_eqs     zSymNode._value_eqr-cCst|j|j|j|j|jfSr!)hashrHr3rMr6r8rDr"r"r$ _value_hashszSymNode._value_hash sympy.BasiccCszt|jts |jjr |jS|jdurtd|jj}|dkr!|jS|jdur.||jkr.|jS|j |j}||_||_|S)Nz$shape_env is required to access exprr) rBrHr- is_numberr1rK_replacements_version_counterrJrIreplace)rEverresultr"r"r$r0s  z SymNode.exprr<cCs|jSr!rMrDr"r"r$r4sz SymNode.hintcCs |jduSr!r]rDr"r"r$has_hint zSymNode.has_hint int | NonecCs|jjr t|jSdSr!)r0rXr-rDr"r"r$ maybe_as_ints zSymNode.maybe_as_int float | NonecCs$ddl}t|j|jrt|jSdSNr)sympyrBr0Floatr.rErdr"r"r$maybe_as_floats zSymNode.maybe_as_float bool | NonecCs,ddl}|j|jur dS|j|jurdSdS)NrTF)rdr0truefalserfr"r"r$ maybe_as_bools   zSymNode.maybe_as_boolcC |jtuSr!)r3r-rDr"r"r$is_intr_zSymNode.is_intcCrlr!)r3r.rDr"r"r$is_float r_zSymNode.is_floatcCrlr!)r3r,rDr"r"r$is_bool r_zSymNode.is_boolcCs"|jduot|jto|jjSr!)rMrBrnode is_nested_intrDr"r"r$rqs   zSymNode.is_nested_intnumcCBt|turtdt|ddl}t|||jt|||dS)NExpected int, got rr6r8)r+r-rKrdrIntegerr1rErrrdr"r"r$wrap_int zSymNode.wrap_intr.cCrs)NzExpected float, got rru)r+r.rKrdrrer1rwr"r"r$ wrap_float!ryzSymNode.wrap_floatcCsHt|turtdt|ddl}t|r|jn|j|jt|||dS)NzExpected bool, got rru)r+r,rKrdrrirjr1rwr"r"r$ wrap_bool*s zSymNode.wrap_boolcC|Sr!r"rDr"r"r$clone8r&z SymNode.clone builtins.strcCs|jSr!r0rDr"r"r$str;z SymNode.strcC|Sr!rrDr"r"r$__str__>rzSymNode.__str__cCsd|jd|jd|jg}|jdur|d|j|jdur+|d|j|jdur9|d|jd|dS) NzSymNode(z , shape_env=z , pytype=zhint=z constant=zfx_node=z, rF)rHr1r3rMappendr6r8join)rErepr"r"r$__repr__As   zSymNode.__repr__cCrr!rrDr"r"r$ _graph_reprMszSymNode._graph_reprcCrr!)_absrDr"r"r$absSrz SymNode.abscCrr!)_posrDr"r"r$posVrz SymNode.posndigitscC ||Sr!)_roundrErr"r"r$roundYr_z SymNode.roundcCrr!)_truncrDr"r"r$trunc\rz SymNode.trunccCrr!)_addrSr"r"r$add_r_z SymNode.addcCrr!)_subrSr"r"r$subbr_z SymNode.subcCrr!)_mulrSr"r"r$muler_z SymNode.mulcCrr!)_modrSr"r"r$modhr_z SymNode.modcCrr!) _float_powrSr"r"r$ float_powkr_zSymNode.float_powcCrr!)_pow_by_naturalrSr"r"r$pow_by_naturalnr_zSymNode.pow_by_naturalcCrr!)_and_rSr"r"r$and_qr_z SymNode.and_cCrr!)_or_rSr"r"r$or_tr_z SymNode.or_cCrr!)_float_truedivrSr"r"r$ float_truedivwr_zSymNode.float_truedivcCrr!) _int_truedivrSr"r"r$ int_truedivzr_zSymNode.int_truedivcCrr!) _int_floordivrSr"r"r$ int_floordiv}r_zSymNode.int_floordivcCrr!)_lshiftrSr"r"r$lshiftr_zSymNode.lshiftcCrr!)_rshiftrSr"r"r$rshiftr_zSymNode.rshiftcCrr!)_sym_notrDr"r"r$r rzSymNode.sym_notcCrr!)_eqrSr"r"r$eqr_z SymNode.eqcCrr!)_nerSr"r"r$ner_z SymNode.necCrr!)_gtrSr"r"r$gtr_z SymNode.gtcCrr!)_ltrSr"r"r$ltr_z SymNode.ltcCrr!)_lerSr"r"r$ler_z SymNode.lecCrr!)_gerSr"r"r$ger_z SymNode.gecCrr!)_floorrDr"r"r$floorrz SymNode.floorcCrr!) _is_integerrDr"r"r$ is_integerrzSymNode.is_integercCrr!) _sym_floatrDr"r"r$rrzSymNode.sym_floatcCrr!)_sym_intrDr"r"r$sym_intrzSymNode.sym_intcCrr!)_ceilrDr"r"r$ceilrz SymNode.ceilcCrr!)_negrDr"r"r$negrz SymNode.negcCrr!)_sym_minrSr"r"r$r r_zSymNode.sym_mincCrr!)_sym_maxrSr"r"r$r r_zSymNode.sym_maxthen_valelse_valcC |||Sr!)_sym_ite)rErrr"r"r$r  zSymNode.sym_itesizes list[SymNode]stridescCrr!)_is_contiguousrErrr"r"r$ is_contiguousrzSymNode.is_contiguouscCrr!)_is_channels_last_contiguous_2drr"r"r$is_channels_last_contiguous_2d z&SymNode.is_channels_last_contiguous_2dcCrr!)_is_channels_last_contiguous_3drr"r"r$is_channels_last_contiguous_3drz&SymNode.is_channels_last_contiguous_3dcCrr!)_is_channels_last_strides_2drr"r"r$is_channels_last_strides_2drz#SymNode.is_channels_last_strides_2dcCrr!)_is_channels_last_strides_3drr"r"r$is_channels_last_strides_3drz#SymNode.is_channels_last_strides_3dcCrr!)'_is_non_overlapping_and_dense_indicatorrr"r"r$&is_non_overlapping_and_dense_indicatorrz.SymNode.is_non_overlapping_and_dense_indicatorcCrr!)rrSr"r"r$sym_orr_zSymNode.sym_orcCrr!)rrSr"r"r$sym_andr_zSymNode.sym_andcCrr!) _bitwise_andrSr"r"r$ bitwise_andr_zSymNode.bitwise_andcCrr!) _bitwise_orrSr"r"r$ bitwise_orr_zSymNode.bitwise_orcCrr!) _bitwise_xorrSr"r"r$ bitwise_xorr_zSymNode.bitwise_xorcCrr!)rrSr"r"r$truedivr_zSymNode.truedivcCrr!)rrSr"r"r$floordivr_zSymNode.floordivcCrr!)rrSr"r"r$powr_z SymNode.powcCs|||t|dS)N)rrto_noderr"r"r$is_non_overlapping_and_denses z$SymNode.is_non_overlapping_and_densecC |ddSNr) guard_intrDr"r"r$int_rz SymNode.int_argsc Csddl}ddlm}m}|r!t||tjtdd|DfiSdd|D}|j|}g}t }|D]} | j dur<n | | j q3t |}|j durPtd|j tjtdd|Df\} } t||j t|| d S) Nrget_proxy_modehandle_sym_dispatchcss|]}t|VqdSr! wrap_node.0ar"r"r$ sz"SymNode.sym_sum..cSg|]}|jqSr"rrr"r"r$ z#SymNode.sym_sum..z!shape_env is required for sym_sumcss|]}|jVqdSr!r8rr"r"r$rsr)rd"torch.fx.experimental.proxy_tensorrrrtorchsym_sumtupleAddrr4rsumr1r@_create_fx_call_functionrr-) rErrdrrexprsout size_hintsout_hintrr8_r"r"r$rs4   zSymNode.sym_sumsize_obliviousbool | int | floatcCs |jdur td|j||S)Nz!shape_env is required to evaluate)r1r@evaluate_sym_node)rEr r"r"r$evaluate#s zSymNode.evaluatefilelinecC0|}zt|WStytd|w)NzFailed to convert to int: %s)rr- ExceptionlogwarningrErrrr"r"r$r)   zSymNode.guard_intcCr)NzFailed to convert to float: %s)rr.rrrrr"r"r$ guard_float3rzSymNode.guard_floatcCr)NFailed to convert to bool: %srr,rrrrr"r"r$ guard_bool=rzSymNode.guard_boolcCsdddlm}|jdurtd|r"||js"|jjs"|||S|jj|j|d||j dS)Nr)free_unbacked_symbolsz%shape_env is required for expect_true:r) r?rr1r@r^r0+prefer_deferred_runtime_asserts_over_guardsrguard_or_defer_runtime_assertr8)rErrrr"r"r$ expect_trueGs   zSymNode.expect_truecC(ddlm}|std|t|S)Nr)statically_known_trueExpected bool type)r?r#rorKr )rErrr#r"r"r$r#[  zSymNode.statically_known_truecCs4|jdd}zt|WStytd|w)aN Like guard_bool, but if we encounter unbacked symbols, if those symbols are size-like, we will treat them as >= 2 for the purposes of the analysis. This CHANGES the runtime semantics, but all size-oblivious sites have been audited to ensure that the runtime semantics don't change in a material way. Acceptable runtime semantic changes are, e.g., squeeze() no longer dropping an unbacked one size, or a tensor reporting as non-contiguous even if it's contiguous if it would have been reported contiguous due to being empty. T)r rrrr"r"r$guard_size_obliviousbs    zSymNode.guard_size_obliviouscCr")Nr)guard_or_falser$)r?r'rorKr )rErrr'r"r"r$r'vr%zSymNode.guard_or_falsecCr")Nr) guard_or_truer$)r?r(rorKr )rErrr(r"r"r$r(}r%zSymNode.guard_or_truecCrr)rrDr"r"r$bool_rz SymNode.bool_cCdS)NTr"rDr"r"r$ is_symbolicr&zSymNode.is_symboliccCr r!r"rDr"r"r$ nested_intr&zSymNode.nested_intcCr*)NFr"rDr"r"r$ is_constantr&zSymNode.is_constant)NNF)r0rr1r2r3r+r4r5r6r7r8rr9r,rr:)r1rrr)rRrrr,)rr-)rrWrG)rr,)rr`)rrb)rrh)rrr-rr)rrr.rr)rrr,rr)rr)rr~r!)rr`rr)rRrrr)rrrrrr)rrrrrr)rrrr)F)r r,rr )rr~rr-rr-)rr~rr-rr.)rr~rr-rr,)rr:)\__name__ __module__ __qualname____doc__r/__annotations__rPrQrTrVpropertyr0r4r^rargrkrmrnrorqrxrzr{r}rrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrr r r rrrrrrrrrrrrrrrrrrrrrr!r#r&r'r(r)r+r,r-r"r"r"r$rYs   Y                                                                   '        rcseZdZdfdd ZZS)_DynamicScalarrrrrcs$|turtdtj|g|RS)Nz9_DynamicScalar is an abstract base class, use DynamicInt.)r4 TypeErrorsuper__new__)clsr __class__r"r$r7sz_DynamicScalar.__new__)rrrr)r.r/r0r7 __classcell__r"r"r9r$r4sr4csTeZdZdZdfdd Zdd d Zdd d ZdddZdddZdddZ Z S)ra User API for marking dynamic integers in `torch.compile`. Intended to be compatible with both compile and eager mode. Example usage:: fn = torch.compile(f) x = DynamicInt(4) fn(x) # compiles x as a dynamic integer input; returns f(4) valr-rrcs2t|tstdt|t|t|}|S)Nrt)rBr-rKr+r6r7)r8r<objr9r"r$r7s zDynamicInt.__new__rcCsd|jdS)Nz DynamicInt(rF)realrDr"r"r$rzDynamicInt.__repr__rRcCst|j|Sr!rr>rSr"r"r$ __floordiv__szDynamicInt.__floordiv__cCst||jSr!r@rSr"r"r$ __rfloordiv__r?zDynamicInt.__rfloordiv__NcCs8|dur t|j||}n|j|}t|trt|S|Sr!rr>rBr-rrErRmodulor\r"r"r$__pow__s   zDynamicInt.__pow__cCs8|dur t||j|}n||j}t|trt|S|Sr!rCrDr"r"r$__rpow__s   zDynamicInt.__rpow__)r<r-rr)rr)rRr-rrr!) r.r/r0r1r7rrArBrFrGr;r"r"r9r$rs     rrrrandrrrrrrrrrcCrr!)rxr"r"r$srKrrrrrrrorrrrrrrrrr r r r rr> rrrrrrrr rnamerCallable[[SymNode], SymNode]cdfdd }|S)NrErrcst|dS)N_sym_)getattrrDrMr"r$fnsz_get_sym_node_fn..fnrErrrr"rMrSr"rRr$_get_sym_node_fnsrV) sqrtcoscoshsinsinhtantanhasinacosatanlog2sym_r >rLrHr r >rrr>rrsym_log2rxor)rrr>rrrr>rrrr> rrrrrrrLrHr rrrrWbcCddlm}|||S)Nr) FloatTrueDiv)torch.utils._sympy.functionsrg)rrergr"r"r$_sympy_float_truedivP  ricCrf)Nr) IntTrueDiv)rhrk)rrerkr"r"r$_sympy_int_truedivVrjrlcCrf)Nr)FloorDiv)rhrm)rrermr"r"r$_sympy_floordiv\rjrncCs0ddlm}m}|jr|jr|||S|||S)NrMod PythonMod)rhrprqis_nonnegative)rrerprqr"r"r$ _sympy_modbs   rscCrf)Nr) PowByNatural)rhrt)rrertr"r"r$_sympy_pow_by_naturalkrjrucCrf)Nr)FloatPow)rhrv)rrervr"r"r$_sympy_float_powqrjrwcCddl}|||Src)rdAndrrerdr"r"r$ _sympy_andw r{cCrxrc)rdOrrzr"r"r$ _sympy_or}r|r~cCrf)Nr)LShift)rhr)rrerr"r"r$ _sympy_lshiftrjrcCrf)Nr)RShift)rhr)rrerr"r"r$ _sympy_rshiftrjr ordered_argslist[sympy.Basic]new_arglist[sympy.Basic] | NonecCst|dkr |gSddlm}m}||d||kr ||gS||d||kr/|g|Sdt|d}}||kra||d}||||}|dkrPdS|dkrY|d}n|d}||ks<||||S)zs If new_arg is found in ordered_args None is returned, else the new ordered_args with new_arg inserted r) _args_sortkeyBasicr;rN)lensympy.core.basicrrcompareinsert)rrsort_keyrlowhighmidcompare_resultr"r"r$_binary_search_insert_args&      rFlhsrhslhs_is_optimized_summationr,rhs_is_optimized_summationtuple[bool, sympy.Basic]c sjddlddlm}d fdd }dd lm}|||O}|||O}|r|r||jd ||jdkr=||j|jS||jd||jd krS||j|jSt|jd krt|jd krt|j}|jD] }t||}|durvnqi|dur||S|r|j rtt|j|}|dur||S|r|j rtt|j|}|dur||S ||} || | fS)a Custom optimization for Add used to optimize incremental binary summations of certain properties. The idea is when we know the expression is a summation of unique symbols all we need to know is the correct order of symbols, and no other optimizations are needed. We pass evaluate=false, with the correct order of args and save the following. 1. Avoid running other optimizations when the Add is constructed. 2. Manually figure out the order of the args for the new expression in log(n) comparisons instead of nLog(n) (comparing terms is expensive and shows in the profiles). The function returns a tuple of (1) a boolean that indicates whether the output is a summation of unique symbols, (2) the result sympy expression. rN)rrrrrcs(|durtdjj|dd}d|fS)Nzordered_args is NoneT)is_commutative)rKr _from_args)rr\rdr"r$make_optimizedsz&_optimized_add..make_optimized)_is_symbols_binary_summationr;r)rrrr) rdrrrhr_argsrlistr is_symbolr) rrrrsortkeyrrnew_argsrr\r"rr$_optimized_adds<          rcCrf)Nr)BitwiseFn_bitwise_and)rhr)rrerr"r"r$rrjrcCrf)Nr)BitwiseFn_bitwise_or)rhr)rrerr"r"r$rrjrcCrf)Nr)BitwiseFn_bitwise_xor)rhr)rrerr"r"r$rrjrrSCallable[..., sympy.Basic]cCsddl}t||jr3|j}t|dkr3t|d|jr3|djr3||d}|d|kr3||dSt||jr@|||ksFt||jrK||S||S)Nrrr)rdrBMulrrrerrv)rrSrdaacoefr"r"r$_floor_ceil_helper s &     rcCddlm}||S)Nr) FloorToInt)rhr)rrr"r"r$ _sympy_floor2 rcCr)Nr) TruncToInt)rhr)rrr"r"r$ _sympy_trunc:rrcCr)Nr) CeilToInt)rhr)rrr"r"r$ _sympy_ceil@rrcCrxrc)rdEqrzr"r"r$ _sympy_eqFr|rcCrxrc)rdNerzr"r"r$ _sympy_neLr|rcCrxrc)rdGtrzr"r"r$ _sympy_gtRr|rcCrxrc)rdLtrzr"r"r$ _sympy_ltXr|rcCrxrc)rdLerzr"r"r$ _sympy_le^r|rcCrxrc)rdGerzr"r"r$ _sympy_gedr|rcCrf)Nr)Min)rhr)rrerr"r"r$ _sympy_minjrjrcCrf)NrMax)rhr)rrerr"r"r$ _sympy_maxprjrfcCsddl}|||f|dfS)NrT)rd Piecewise)rrrrdr"r"r$ _sympy_itevsr$Callable[[sympy.Basic], sympy.Basic]crO)NrrWrcs"ddl}t|jjjd|S)NrOpaqueUnaryFn_)rhrQutils_sympy functions)rrrRr"r$rSsz_get_sym_math_fn..fnrrWrrWr"rUr"rRr$_get_sym_math_fnsr_sympy_cCsddl}||Src)rdAbsrrdr"r"r$ _sympy_abss rnumberrsympy.Basic | NonecCs*ddlm}m}|dur||S|||S)Nr) RoundDecimal RoundToInt)rhrr)rrrrr"r"r$ _sympy_rounds rcCrNr)ToFloat)rhr)rrr"r"r$_sympy_sym_floats rcCs*ddl}ddlm}|||||Sr)rdrhrrr)rrdrr"r"r$_sympy_is_integers r)rrrrcCs$t|}t||tt|dddS)Nrr;)rsympy_is_contiguous_genericrrange)rrdimr"r"r$sympy_is_contiguoussr dim_order list[int]cCsddl}t|}t||kr|jS|j}|jj}|D]}|||||jj||||BM}|||9}qt|D]}|||||jjO}q;|Src) rdrrjriSOnerrZero)rrrrdrrzdr"r"r$rs ( rcCt||gdSN)rrrrrrr"r"r$$sympy_is_channels_last_contiguous_2drcCrN)rrrrrrr"r"r$$sympy_is_channels_last_contiguous_3drrc Csddl}ddlm}t|}|t|kr|jS|jj}|j}|||ddM}|D]+}||||d|||k@M}|dkrJ||||dM}|||||d}q*|S)Nrrr) rdrhrrrjrrrir) rrrrdrrmrrr"r"r$&sympy_is_channels_last_strides_generics    rcCrrrrr"r"r$!sympy_is_channels_last_strides_2d(rrcCrrrrr"r"r$!sympy_is_channels_last_strides_3d.rrcCsddlm}|g||RS)Nr)!IsNonOverlappingAndDenseIndicator)rhr)rrrr"r"r$-_sympy_is_non_overlapping_and_dense_indicator4s r)rrrrrrrErrcCsVt|tr|jSt|tur||St|tur||St|tur)| |St Sr!) rBrCrpr+r,r{r-rxr.rzNotImplemented)rErrr"r"r$rHs       rrJ0SymInt | SymFloat | SymBool | int | float | boolcCsXt|tr |jdur |jS|rt|S|rt|S|r%t|St d|)Nzunrecognized return type ) rBrr6rmrrnrror rKrIr"r"r$rWsrmethodCallable[..., object]cCst|Sr!)METHOD_TO_OPERATORrr"r"r$rerrfuncr:c stdtvrd}n}ddd}dfd d }|dfdd }|d fdd }tvrAttd||dSdkrXd!fdd }ttd||dSdkrpd"d#fdd }ttd||dSttd||dS)$Nr rset[str]cSsJddl}|jj|jj|jjj|g}ddl}dd|D|jj BdhBS)NrcSsh|]}t|qSr")inspectgetfile)rrr"r"r$ }z@_make_node_magic..uninteresting_files..z) r_dynamo eval_framerfx experimentalrtorch._dynamo.guardsguardsuninteresting_files)rmodsr"r"r$r qs  z-_make_node_magic..uninteresting_filesrSCallable[..., SymNode]cs tdd fdd }|S) NrErrRSymNode | Nonercsj|dur |n||tjjjr3|dur||gn|gd fdd tdfdd d S) Nrrrr`cs`ddl}|jdur dSt|tkrdSt|j|j|jfr!dS|j|j|jfvr,dSt|Src) rdr6idrBr0rvrerirj)rrd)r\r"r$get_ids zM_make_node_magic..capture_provenance..wrapper..get_idexpression_createdc s@ttddDfddDtdtddS)NcSg|]}t|qSr"rrr"r"r$rzc_make_node_magic..capture_provenance..wrapper....cs g|] }|dur|qSr!r")ri)rr"r$rsr)rr\ result_id arguments argument_ids user_stackstack)rr structuredget_user_stackget_framework_stackr")rrrr\r"r$rKs  zO_make_node_magic..capture_provenance..wrapper..) metadata_fn)rrrr`)r_logging _internalGET_DTRACE_STRUCTUREDrrS)rSr)rrr\r$wrappers    z=_make_node_magic..capture_provenance..wrapperr!)rErrRrrr) functoolswraps)rSr!r)rSr$capture_provenances*z,_make_node_magic..capture_provenancerErrRc sddlm}m}t}t}|jdur|jdur||j|j}|r1t|||t|t|fiSt|t s?t dt |d}zdkrddl m }m}|j} | durYt d|jjsf| |jjdkr{|jjss| |jjdkr{||j|j} nv||j|j} nndkrt|j|j|j|j\}} n\d vrddl} dd lm} m} |jjo| |j| j}|jjo| |j| j}|r|jjs|r|jjr| j| j| j| j | j!| j"d }||j|jdd } n|j|j} n|j|j} Wnt#yt$%d |j|jwt&'d |j|j| t(vrt)}nt*vr!t+}n|j,t)us-|j,t)ur0t)}n|j,}|durL|turL|durLt|t-sL||}|jdurVt.d|j/||j0|j0f\}}t | |j||||d}|S)NrrzExpected SymNode, got Frrozshape_env is required for modr)rrrrrr)symbol_is_typeSymT)rfailed to eval %s(%s, %s)z%s %s %s -> %sz#shape_env is required for binary op)r8r9)1rrrrrr4rrrBrrKr+rhrprqr1r0rr bound_sympylowerrr/rdtorch.utils._sympy.symbolr%r&r UNBACKED_INTrXrrrrrrrrr sym_node_logdebugalways_float_magic_methodsr.always_bool_magic_methodsr,r3rCr@rr8)rErRrropr r9rprqr1rrdr%r&lhs_is_unbackedrhs_is_unbacked rel_classr3r8r r\rrr"r$binary_magic_impls            z+_make_node_magic..binary_magic_implc sddlm}m}t}|rt|||t|fiS|j}|jdur'tddks/dkr5|j |}z|}Wnt yJt d|wt d||t}|jdur_||j}tvrft}ntvrmt}n tvrtt}n|j}|j||jf\}} t||j|||dS) Nrrz"shape_env is required for unary oprceilingzfailed to eval %s(%s)z %s %s -> %sr)rrrrrrr0r1r@_simplify_floor_divrrrr,r-rr4always_int_magic_methodsr-r/r,r.r.r3rr8r) rErrr0r0rr r3r8r r4r"r$unary_magic_impl0s8      z*_make_node_magic..unary_magic_implr pred_node then_node else_nodec sddlm}m}|jdurd}n |jr|j}n|j}|r/t||tt|t|t|fiSz |j|j|j}WntyNt d|j|j|jw|j durXt d|j t|j|j|jf\}}t||j |j||dS)Nrrzfailed to eval %s(%s, %s, %s)z!shape_env is required for sym_iter)rrrr4rr rr0rrrr1r@rr8rr3) r:r;r<rrr rr8r r4r"r$ sym_ite_impl[sL    z&_make_node_magic..sym_ite_implrrr`c sddlm}m}tj}|rt|||t||fiS|j}z||}Wnty5t d||w|dur=t }n|j }d}|j durM||j |}|jg} |durZ| ||jdurctd|j|t| \} } t||j||| dS)Nrrz!failed to eval %s(%s, ndigits=%s)zshape_env is required for roundr)rrrbuiltinsrrrr0rrrr-r3r4r8rr1r@rrr) rErrrr0r0rr3r rr8r r4r"r$ round_impls8     z$_make_node_magic..round_impl)rr)rSr rr )rErrRrrrrT)r:rr;rr<rrrr!)rErrr`rr)r2magic_methods_on_operator_with_trailing_underscore unary_methodssetattrr) rr method_attrr r$r5r9r=r?r"r4r$_make_node_magicis&   .&1-rDcs\dfdd }ttd |dfd d }ttjts,ttjt|dSdS)NrErrrrrc sddlm}m}ttjt}|r(t|||dd|Ddd|DfiSdd|D}dd|D}z||}WntyMt d||wg} d} |D]} | j dur]n | | j qTg} |D]} | j durqn | | j qh|| | }  drt} nt} t||j| | S) NrrcSrr"rrsr"r"r$rrzH_make_node_sizes_strides..sizes_strides_impl..cSrr"rrEr"r"r$rrcSrr"rrEr"r"r$rrr' _indicator)rrrrQsysmodulesr.rrrrr4rendswithr-r,rr1)rErrrrr0 size_exprs stride_exprsrr r rF stride_hintsr3r4r"r$sizes_strides_implsF     z4_make_node_sizes_strides..sizes_strides_implr  list[object]rcsddlddlm}t||D]"ttr2ttj fdd|Dfdd|DSqdkr<|||St fdd|Dfdd|DS) Nr)!eval_is_non_overlapping_and_densecg|]}tj|qSr"rrprrerr"r$rzH_make_node_sizes_strides..sizes_strides_user..crQr"rRrSrTr"r$r rUrcg|]}|qSr"sympifyrrr"r$rrcrVr"rWrrr"r$rr) rdr?rP itertoolschainrBrrrQrpr,)rrrPr4rr$sizes_strides_users,   z4_make_node_sizes_strides..sizes_strides_user)rErrrrrrr)rrOrrOrr)rBrhasattrrHrIr.)rrrNr[r"r4r$_make_node_sizes_stridess 2 r] user_typec stvr dnd2ddd3d d tvr d4d dnd4ddd5fdd d6fdd }d7fdd }d7fdd }d8d!d"}tvrd||d#d#|dStvrxt|}||t||dSd$krd9fd)d* }||d#d#|dSd+krd:d;fd/d0 }||d#d#|dS} tvrt} ||d#| d#|tvr||d1| d#|dSdS).get_constantr,cSs2t|tttfr dSt|tttfr|jSdS)NTF) rBr-r.r,rrr rpr-rIr"r"r$r-9s  z%_make_user_magic..is_constantrrcSs"t|trt|jt|S|S)z;Implements True+True=2, which works in python but not sympy)rBr rrprxr-rIr"r"r$promote\s z!_make_user_magic..promotecSr|r!r"rIr"r"r$rbdr&rErRtuple[Any, Any]cs\dvr||fSt|ttjf}t|ttjf}|s|r*|s#t|}|s*t|}||fS)N)rrrrrrrr r rrrrrr)rBr.rrr)rErRf_selff_otherrr"r$promote2gs  z"_make_user_magic..promote2cs2|}|rt|Stt|jSr!)rrrQrprD)rar-rrCrbr"r$r9sz*_make_user_magic..unary_magic_implcst|ttttttfs tSt d|||}|}||\}}|r1t ||S|r9|}t |j |}|turEtSt t|j |}|rW|S|S)NzMAGIC %s %s %s)rBr-r.r,rrr rr,r-rrrprrQrErR other_noderetrar-rrCrbrfr"r$r5s z+_make_user_magic..binary_magic_implcst|ttttttfs tS|}|}||\}}|r)t||S|r1|}t |j |}|tur=tSt t ||j }|rO|S|Sr!) rBr-r.r,rrr rrrrprrQrgrjr"r$rbinary_magic_impls z,_make_user_magic..rbinary_magic_implr^r+attrr symnode_implr:cs6t||dfdd }|turtt|dSdS) z Registers the SymNode magic method on SymInt/Float/Bool, and optionally registers a corresponding wrapped method on DynamicInt. rrrrcs<dd|D}tt|}t|trt|tst|S|S)NcSs g|] }t|tr |jn|qSr")rBrr>)rrJr"r"r$rszP_make_user_magic..setattrs..dynamic_int_impl..)rQr-rBr,r)rrrlr"r$dynamic_int_implsz<_make_user_magic..setattrs..dynamic_int_implN)rrrr)rBrr)r^rlrmror"rnr$setattrss  z"_make_user_magic..setattrs__r predr rrcs|j}t||}t||}|tus|turtSt|tr't|tr'|j|jks+tdtt|j||}|j r?|S|S)Nz9then_node and else_node must be SymNodes with same pytype) rprrrBrr3rKrrQr-)rrrrr:r;r<ri)rarCr"r$sym_ite_magic_impls&   z,_make_user_magic..sym_ite_magic_implrrrr`cs,|r t||Stt|j|Sr!)r>rrrQrpr)rar-rr"r$round_magic_implsz*_make_user_magic..round_magic_impl__r)rJr_rr`)rJr_rr,)rJrrr)rErrRrrrc)rErrr)rErrRrrr)r^r+rlrrmrrr:)rrr rrrrrrr!)rErrr`rr)r@bool_becomes_int_magic_methodsunary_magic_methodsunary_nonmagic_methodsrQr bitwise_opsreflectable_magic_methods) rr^r9r5rkrporigrsrt method_namer"rjr$_make_user_magic&s>   !  *  r})rrrr)rr'rr()rr)rr*)rr+rr+)rMrrrN)rrWrerWrrW)rrrrWrr)FF) rrWrrWrr,rr,rr)rrWrSrrrWr)rrWrrWrrWrrW)rMrrrr!)rrWrrrrW)rrrrrrW)rrrrrrrrW)rErrrrrr)rJrrr)rrrr)rrrrrr:)rrr^r+rr:) __future__rr>r"rrYloggingmathoperatorrHrrtypingrrrrtorch._logging.structuredrrrr r r r r rrtorch._loggingrcollections.abcrrrdr?r getLoggerr.rgetArtifactLoggerr,rrr2r,r.r-HintType__all__ torch.typesrrCr%rr4rrrrrrrrrrrrrrrrrrrrrdrrrrrrrwrV math_op_namesrMsym_name priv_sym_namerBrQrrxrAonly_bool_magic_methodsrvalso_bool_magic_methodsbool_magic_methodsonly_float_magic_methodsr@ryr.r8r/rirlrnrsrurwr{r~rrrrrrrrzrrrrrrrrrrrrrrIcurrent_modulerpriv_sympy_namerSr0rrrrinvertrrrrrrrrrsizes_strides_methodsrrrrDr]itemsrrr}r"r"r"r$s^ (            <4      !"#&                ' G                                      *       Z^ [