i(UdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddl mZmZddlmZmZmZmZmZmZddlmZddlmZddlZdd lmZdd lm Z dd l!m"Z"d d l#m$Z$m%Z%m&Z&m'Z'd dl(m)Z)m*Z*m+Z+d dl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7d dl8m9Z9m:Z:d dl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDd dlEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMddlNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZV ddlWmXZXer.ddlZm[Z[ddl\m]Z]m^Z^m_Z_m`Z`ddlambZbddlcmdZdmeZeddlfmgZgmhZhddlimjZjede defZkd Zld!Zmenhd"Zoend#hZpd$ZqeZreeefesd%<Gd&d'etZuejd(eeedfdzd?eedzd@eze{efdzdAeze{efdzd(e j fdBZhdCZd.d/dDed5e dzd=e{d(eSf dEZGdFdGeSZGdHdIeZGdJdKeZGdLdMeZGdNdOeZGdPdQeSZGdRdSeZGdTdUeZGdVdWeZGdXdYeZGdZd[eZGd\d]eZd.d/dDe defd=e{d1eeSd2eze{eSfd(eSf d^ZGd_d`eZGdadbeZGdcddeSZGdedfeZGdgdheSZGdidjeZd(ezeeffdkZd.d/dDe defd(eis_leaf namespace none_is_leafrQzihttps://github.com/pytorch/pytorch/issues/new?&labels=oncall%3A+pt2&projects=&template=pt2-bug-report.yml _spec_cachec eZdZy)ClosureConversionErrorN)__name__ __module__ __qualname__r/var/www/vps2.regionflexible.com/Desarrollo/venv/lib/python3.12/site-packages/torch/_dynamo/variables/functions.pyrVrVsr[rVreturnc TttttddddS)Ntorchutils_pytreeSUPPORTED_NODES)r(r.rZr[r\!get_pytree_SUPPORTED_NODES_sourcercs( :l73W=yI r[c,eZdZdeddfdZdeddfdZy) FunctionSpecfuncr]Ncp|j}|j}|j|_|j|_|j |_|d|j|_||j|j |_ |j|jz|_ ||j |j |jz|_ |j |jz}|jtzr||nd|_||jrdndz }|jtzr |||_yd|_yNr9r)__code__ co_varnamesco_posonlyargcount posonly_count co_argcount arg_countco_kwonlyargcount kwonly_count posonly_namespos_or_kw_names all_pos_names kwonly_namesco_flags CO_VARARGS varargs_nameCO_VARKEYWORDS varkw_name)selfrfcodevnoffs r\__init__zFunctionSpec.__init__s}}   !44)) 22 4$"4"45!$"4"4t~~F!//$2F2FFt~~ARAR0RSnnt000'+}}z'ABsGt D%%q1,%)]]^%C"S'r[c |jxsd|_|jxsi|_t t |j t|j dtt|j|_ yNrZ) __defaults__defaults__kwdefaults__ kwdefaultsdictziprslenrangepos_default_map)rzrfs r\update_defaultszFunctionSpec.update_defaultssi))/R --3 $ ""C $6#6#895T]]AS;T U r[)rWrXrYrr~rrZr[r\reres+N\NdN$  L  T  r[rerfc\tj|}|t|}|t|<|SN)rTgetre)rfspecs r\ _get_specrs. ??4 D |D! D Kr[txrE fn_sourceargskwargsc t|}t||jk(rh|js\|sZ|jsN|j sB|j s6t|jDcic]\}}|t|||c}}S|j|i}t|} |jjD]d\}} d} |r>tj|j | rt"j$s t'|| } t||j | | ||<ft|jD]i\}}|t|krt|||||<'|| vr-||j(vrt|| j+|||<X||vs]t-d||t|jd} |jr#t|t/| ||j<n/| r-t-dt|dt|j|j D]p}|| vrt|| j+|||<&||j0vr0d} |rt'||d} t||j0|| ||<dt-d||j rt|| ||j <|S| rt-dt3| |Scc}}w)Nz&missing required positional argument: z#Too many positional arguments: got z , expected T)is_kwz(Missing required keyword-only argument: zUnexpected keyword arguments: )rrrnrrwryrt enumeraterswrap_bound_argrrritemsr@ is_literalrr%skip_guards_on_constant_func_defaultsr,rqpop TypeErrortuplerlist)rfrrrrrinamebarem_kwidxdefault_sourceextrakwdefault_sources r\bind_args_cachedrs T?D D T^^#!!!!!!%T%7%78 4 .T!W- -    B &\F))//1J c   ' ' c(: ;<<+Is;N!"dmmC&8.I4JT//0M4 s4y=%b$q'2BtH V^ ** *&b&**T*:;BtH ^DTFKL L!M& T''(* +E  .r5< @4   1#d)KDL^L^H_G` a  !! O 6>%b&**T*:;BtH T__ $# #1)T#N %b$//$*?AQRBtHFtfMN N O ,R84?? I 8fGHH IE s.K#valsourcect|tr|S|stj||Stjj ||Sr) isinstancer>buildrLazyVariableTrackercreate)rrrs r\rr sD#' $$R--,,33C@@r[resultct|jD]+\}}t|ttfst ||||<-yr)rrrrrr)rrkvs r\wrap_args_kwargsrs>V\\^$.1 a% '&r1-F1I.r[parentr{c|jj}|jD]<}|j}||vr!|j ||j ||||<>y)z Update `result` to add mapping from local name to new cells created directly by `code`, or update SideEffects in `parent` if the a local cell is already in `result` (cell argument). N)output side_effects co_cellvarstrack_cell_new store_cellr)rrr{rrnew_cells r\ init_cellvarsr!sa==--L   ..0 6>  # #Hfjj.> ?t  r[ f_globalsrrclosurer annotationscddlm}||||||}||_t|trddlm} t| |}|t|tsJ||_|S)Nrrpairwise) typesrrrr itertoolsrr__annotations__) r{rrrrrrrrfrs r\_create_nested_fnr6sa# ix AD$D+u%&8K01   *[$"?? ?&D Kr[>__doc__ri __closure__ __globals__rrrfncN|xr t||}|r|dk(r t|}d} tj||}|t vr t||}|r tjj||Stj||S#t$rt t|YgwxYw)Nr) r(r/inspectgetattr_staticAttributeErrorr"fn_known_dunder_attrsgetattrrrrr>r)rrrrsubobjs r\fn_var_getattrr[s 0 640F $++!( F5''D1 $$T" ,,33FFCC  V ,, 5 !45sBB$#B$ceZdZdefdZdefdZdeeeffdZde jfdZ de fdZ ddd eed eeefdefd Zddd edefd ZdddeeeffdZde fdZy)BaseUserFunctionVariabler]c6|jjSrget_code co_filenamerzs r\ get_filenamez%BaseUserFunctionVariable.get_filenamew}}***r[c6|jjSrrco_namers r\get_namez!BaseUserFunctionVariable.get_namez}}&&&r[ctrNotImplementedErrorrs r\ get_globalsz$BaseUserFunctionVariable.get_globals}!!r[ctrrrs r\rz!BaseUserFunctionVariable.get_coderr[ctrrrs r\has_selfz!BaseUserFunctionVariable.has_selfrr[rrErrc|jdk(r%|jjdrtS|j |g|j ||S)Npatch_track_step_calledztorch/optim/lr_scheduler.py)rrendswithr?inline_user_function_return self_argsrzrrrs r\ call_functionz&BaseUserFunctionVariable.call_functionsY MMO8 8!!#,,-JK) )--d4Ndnn6F4N4NPVWWr[rcd} t|j|}t j j|S#t$r|dk(rt|trd}YAwxYw)NFrWT)hasattr get_functionrrNestedUserFunctionVariablerr@rrzrrrs r\call_obj_hasattrz)BaseUserFunctionVariable.call_obj_hasattrse T..0$7F))0088# z!j7Q&R s= A A ciSrrZrzrs r\ closure_varsz%BaseUserFunctionVariable.closure_vars r[cyNTrZrs r\ should_allow_nested_graph_breaksz9BaseUserFunctionVariable.should_allow_nested_graph_breaksr[N)rWrXrYstrrrrrrrCodeTyperboolrrr>rr@rrrrZr[r\rrvs+c+'#'"T#s(^""%..""$" X # X' XS/)* X  X 9) 914 9  964_@T;U $r[rc eZdZdZddhej ZehdZede de ddfdZ d+de je jjzded e dd ffd Zde ffd Zdeefd Zde jfdZde j.fdZdefdZdefdZdeee ffdZdefdZ ddde!ed eeefdeeeffdZ"dddedefdZ#dddede$fdZ%ddde!ed eeefdeffd Z&ddde!ed eeefded zfdZ'defdZ(defdZ)ddde!ed eeefde*de!eeeeffd zfd Z+de jd zfd!Z,d"ede*ed#fd zfd$Z-de deed zfd%Z.de/d&fd'Z0de1fd(Z2d)e3defd*Z4xZ5S),UserFunctionVariablez-Some unsupported user-defined global functionr is_constant> optree.opstorch.utils._pytreetorch.utils._cxx_pytreeoptreevaluerr]cft|jtj|||SNrr' make_guardr& CLOSURE_MATCHclsr rs r\create_with_sourcez'UserFunctionVariable.create_with_sources(f'' (B(BCD5((r[rNc Bt|d i|t|ddrd|_nd|_t |t j tjjfs!td|ddgtjtj|d|}||_y) N_dynamo_marked_constantFTz1can't handle functions not implemented in python z2Dynamo can only handle functions defined in pythonz9Move usage of this function out of `torch.compile` regiongb_typecontext explanationhints_torchdynamo_inlinerZ)superr~rrrrrr_jitScriptFunctionr$rINFERENCE_MODErrrrzrrr __class__s r\r~zUserFunctionVariable.__init__s "6" 20% 8#D $D "u115993K3KLM K$PO&55   # #B(=r Br[cXt|tr |jSt|Sr)r7rrras_python_constant)rzr s r\r"z'UserFunctionVariable.as_python_constants% $, -77Nw)++r[cgSrrZrs r\rzUserFunctionVariable.self_argsrr[c|jSrrrs r\rz!UserFunctionVariable.get_function wwr[c.|jjSr)rrirs r\rzUserFunctionVariable.get_codeswwr[c"tjSrrrrs r\ python_typez UserFunctionVariable.python_type!!!r[c4t|jddduS)N__self__)rrrs r\rzUserFunctionVariable.has_selfstww D1==r[c.|jjSr)rrrs r\rz UserFunctionVariable.get_globalssww"""r[cn|j}|r&t|tjr |j}|Sr)rrrUserMethodVariable source_fn)rzrs r\ get_sourcezUserFunctionVariable.get_sources+ jy'C'CD^^F r[rrErc*|jrJ|j}t|ts t d|j j }|j}t|||||}t|||j|jjxsd}t|t|jjjk(sJttj |jjj|D]\} } } |j j"} | | vr| | } n|rYt%t'|| }t)|d| } t+j,|| j.|}| j7|| |} n4 t+j,|| j.}| j7d| |} | || <|S#t0$rt3j4}YpwxYw#t0$rt3j4}Y^wxYw)z Assume `args` and `kwargs` are VariableTracker arguments for a call to this function, create new bindings for initial locals. z'Only supports regular Python functions.rZ cell_contents) freevar_nameN)rrrrrrroot_txr2rrrirr co_freevarsrrcountrr-r*r)r>rr4 ValueErrorrDeletedVariabletrack_cell_existing)rzrrrrr6rrrrrcellrcell_var closure_cellclosure_cell_contents contents_vars r\ bind_argszUserFunctionVariable.bind_argss####!%"l+EF F--''"!"gvtVDffbkk2''%%+7|s477#3#3#?#?@@@@" OO tww//;;W " $OCt"==55L|#'-,]6-BCH (: /)%?#2#8#8 2 24I$L (;; $ ?#2#8#8ASAS#TL(;;D$ U#F4LE" $H '"?#,#<#<#>L?"?#,#<#<#>L?s$!G G2G/.G/2HHrrc|tvrtj||S|j}t ||j ||Sr)r3rGetAttrVariabler2rr)rzrrrs r\ var_getattrz UserFunctionVariable.var_getattr>s? ) ),,T48 8"b$''6488r[clt|j|}tjj |Sr)rrrr@rrs r\rz%UserFunctionVariable.call_obj_hasattrDs+$'))0088r[c n |jtjjur |Dcgc]}|j }}|j Dcic]\}}||j }}}tjj|i|j } tj| S|jtjjurt tj|jj|i|} | jdj } t!| t"sJtj$| S|jtjj(ur"tj|jj|i|} | j*d} t!| t,sS| j/}d|j0d}t3dd |j4d |d |d |gt6j8 t!| t:s,| j=}d |d}t3d||d|ddg | j}tj>|tjj@jBS|jDr'tG||j|j=||S|jHjJjLst|jtjjNjPurDtjjRjU|5tV||||cdddSt[|jHjJdddk(r|jHjJj\sq ddl/m0}|h|j|jb|jdfvrDtjjRj]|5tV||||cdddS|jg|||}||StV||||Scc}wcc}}w#t$r} td|d|| d} ~ wwxYw#t&$r} td|d|| d} ~ wwxYw#1swY8xYw#t&$rd}YwxYw#1swYxYw)NzCannot convert patch_dynamo_config args/kwargs to constants. Please fix your call to patch_dynamo_config by using simpler inputs. args: z , kwargs: error_on_graph_breakz\Improper error_on_graph_break() call. Please fix your call to error_on_graph_break(). args: rz=`nonstrict_trace` expects a callable, but got value of type <>zTypeError from user codezcall_function(, )rz(Applying `nonstrict_trace` to function ; however, `nonstrict_trace` currently requires the function to be defined outside `torch.compile` region.zLimitation of `nonstrict_tracezmake sure definition of z is outside z`torch.compile` regionkind descriptionz!torch.utils.checkpoint.checkpoint) FSDPState)4rr__dynamopatch_dynamo_configr"rchangesrDynamoConfigPatchVariabler: RuntimeErrorrGr signaturebind argumentsrrErrorOnGraphBreakVariable Exceptionnonstrict_tracerrr*rWr$r r USER_ERRORrrTorchInGraphFunctionVariableAllowInGraphKindNONSTRICT_TRACErinvoke_and_store_as_constantrcurrent_tracer,unsafe_allow_externally_visible_side_effectsr`8_disable_side_effect_safety_checks_for_current_subtracerr2allow_externally_visible_side_effects_in_subtracerrrrallow_side_effects_in_hop/torch.distributed.fsdp._fully_shard._fsdp_staterN _pre_forward _post_forward_maybe_call_tree_map_fastpath)rzrrrarg args_constkeyr kwargs_constrQerNrGfn_vartypmsgfn_namerrNtree_map_resultr s r\rz"UserFunctionVariable.call_functionJs 77emm77 7 BFG3c446G GBH,,. 6>c3C//11    --;;#/'!::7CCWW :: : 7))$''277HH',*($$&%""6=== ::;OPPWW 55 53G%%dgg.33TDVDEZZ]Ff&>?((*UVYVbVbUccde6,TZZL4&6(!L #*55 f&:; //+@ Juv<#f #27)<H0 B9999II    /DGGT]]_dF   ((UU}}""[[\++^^ ?w,Rv> ? ? BII,,mT B2 3II,,FF !U$&&''5*]]//II"MC 70T6BCC< V96 6*.' vx99-H   ::<  $4  68T2  &::;LM >8"6:t4 h 2 2 3Or[selector.c|jsy |j}|j|}|syt d|Dsyt t j|S#t$rYywxYw)Nc3<K|]}t|tywr)rtype).0rns r\ zDUserFunctionVariable._extract_tree_map_only_types..!s>S:c4(>)is_python_constantr"r_flatten_type_specallrrfromkeys)rzr raw_value flatteneds r\rz1UserFunctionVariable._extract_tree_map_only_typessw**,  335I++I6 >I>>T]]9-..#  sA(( A43A4c`t|tr|gSt|tr1g}|D](}|j|}|y|j |*|St t dd}|Gt||r;g}|jD](}|j|}|y|j |*|Sy)N UnionType)rrrrextendrr__args__)rzr  collectedentryflat union_types r\rz'UserFunctionVariable._flatten_type_spec%s eT "7N eU #$&I '..u5<  &  '  UK6  !j &CI '..u5<  &  '  r[TcyrrZrs r\is_python_hashablez'UserFunctionVariable.is_python_hashable;rr[c,t|jSr)hashrrs r\get_python_hashz$UserFunctionVariable.get_python_hash>sDGG}r[othercjt|tjxr|j|juSr)rrrrrzrs r\is_python_equalz$UserFunctionVariable.is_python_equalAs*%!?!?@XTWWPUPXPXEXXr[F)6rWrXrYrr_nonvar_fields frozensetr classmethodrrrrr_rrrr~r"rr>rrrrrr*rrrrrr2rrArDr@rrrgrtrrrsrrrr rintrobjectr __classcell__r s@r\rrs&7  " 0 0N " )s)C),C, 40e00 %.. "T">$>#T#s(^#F<'<'<S/)* < c?" # <|959S9_9 9)9149 9 i7 #i7'i7S/)* i7  i7V # ' S/)*  4   B t  D $K #$K'$KS/)* $K  " _ % o% & (    $KL 5+=+=+D /'/ tSy D /"T T0A,GDMYVYYr[rcDeZdZdZdddeedeeefdeffd ZxZ S)InspectSignatureVariablea Variable tracker for inspect.signature with caching support. inspect.Signature is expensive to trace. When inspect.signature is called repeatedly on the same function during tracing, we cache the result to avoid retracing the signature construction each time. Although this is different from CPython behavior, it is safe to do so because inspect.signature does not change across different calls to the same function. rrErrr]c^t|dk(r|s|d}d}t|ttfr|j }|]||j j vr|j j |St|!|||}||j j |<|St|!|||Srh) rrrr0rrsignature_cacherr)rzrrr target_arg cache_keyrr s r\rz&InspectSignatureVariable.call_functionPs t9>&aJI*';=O&PQ&335 $ 9 999944Y??.r4@7= )))4 w$Rv66r[ rWrXrYrrr>rrrrrs@r\rrEsG7 #7'7S/)* 7  77r[rceZdZdhejZdeedfdededdffd Z defdZ d ede fd Z d d d e edeeefdefdZxZS)rr.r{rr]Nc @t|di|||_||_yr)rr~rr{)rzrr{rr s r\r~z$TreeMapOnlyFunctionVariable.__init__os$ "6"* r[ctSrrrs r\r*z'TreeMapOnlyFunctionVariable.python_typeysr[nodec |jtfd|jDS#t$rYywxYw)NFc36K|]}t|ywr) issubclass)rallowed node_types r\rzDTreeMapOnlyFunctionVariable._matches_allowed_type..sTg:i1Ts)r*ranyr)rzrrs @r\_matches_allowed_typez1TreeMapOnlyFunctionVariable._matches_allowed_type|sC ((*ITASASTTT#  s 1 ==rrErc|s|jj|||S|d}|j|r|jj|||St|dk7s|r|jj|||S|S)Nrr9)r{rrr)rzrrrleafs r\rz)TreeMapOnlyFunctionVariable.call_functions} ;;,,Rv> >Aw  % %d +;;,,Rv> > t9>V;;,,Rv> > r[)rWrXrYrrrrr>rr~r*rrrrrrrrs@r\rris ! 0 0N T3Y'    TU/UdU #'S/)*   r[rc eZdZ d dejdededdffd ZededefdZ d d d e e de e e fde fd ZxZS)BuiltinMethodVariablerrrr]Nc jt|di|t|tjsJ||_yr)rr~rrBuiltinMethodTyperrs r\r~zBuiltinMethodVariable.__init__s2 "6""e55666r[objc|j}|j}|tuxr|dk(xst|tuxr|dk(S)N__new__ __contains__)r-rWrrr)r method_self method_names r\is_supported_builtin_methodz1BuiltinMethodVariable.is_supported_builtin_methodsIll ll u$A )A   * L{n/L r[rrErc|jj}|jj}|jxrt |jd}t j |||d}|j||||S)Nr-T)realize)rr-rWrr(r>r call_method)rzrrrrr obj_sourceobj_vts r\rz#BuiltinMethodVariable.call_functionsh gg&& ww[[HZ Z%H  &&r; DQ!!"dD&99r[r)rWrXrYrrrrr~ staticmethodrrr>rrrrrs@r\rrs?D))8<PS      : # :' :S/)* :  :r[rc eZdZdejdeeefdddeddf fd Zdejfd Z defd Z defd Z de fd Z defd ZdefdZdefdZeZd&dZdeeeffdZdefdZdddefdZdddedefdZdddefdZdddefdZdddeefdZdddeegefddfdZde dfdZ!ddd eddfd!Z"defd"Z#defd#Z$ddded$eedeeefdef fd% Z%xZ&S)'LocalGeneratorObjectVariabler{r inline_tracerrCrr]Nc Nt|di|||_||_||_yr)rr~r{rr)rzr{rrrr s r\r~z%LocalGeneratorObjectVariable.__init__s+ "6" "*r[c|jSr)r{rs r\rz%LocalGeneratorObjectVariable.get_codes yyr[c6|jjSrrrs r\rz)LocalGeneratorObjectVariable.get_filenamerr[c6|jjSrrrs r\rz%LocalGeneratorObjectVariable.get_namerr[ctd)Nrrrs r\rz)LocalGeneratorObjectVariable.get_functions !.11r[cyNFrZrs r\rz%LocalGeneratorObjectVariable.has_selfr[c"|jSr)rrs r\rWz%LocalGeneratorObjectVariable.__name__s}}r[cV|jjd|jdS)N(rJ)r rWrrs r\__str__z$LocalGeneratorObjectVariable.__str__s'..))*!DMMO+>r[cddlm}ddlm}m}|j }||}||}||}|5|5|5|j } | js|j||_ tj|jj|dddddddddy#1swYxYw#1swYxYw#1swYyxYw)Nr)"disallow_side_effects_in_generator) save_and_restart_speculation_log(temporarely_allow_writes_to_output_graph) torch._dynamo.side_effectsrtorch._dynamo.symbolic_convertrrrrgenerator_exhaustedforce_unpack_var_sequenceremaining_itemsrListIteratorVariable reconstruct) rzcodegenrrrrsavedisallowtemptracers r\rz(LocalGeneratorObjectVariable.reconstructsQ ZZ/35b97;  V8 VT V''F--'+'E'Eb'I$  * *4+?+? @ L LW U  V V V V V V V V Vs:C B=AB1B= C 1B: 6B==C C  Cc|jSrrrs r\rz(LocalGeneratorObjectVariable.get_globals ~~r[c"tjSr)r GeneratorTypers r\r*z(LocalGeneratorObjectVariable.python_types"""r[rrFc |j}|jrtt| |j S#t $r}d|_|d}~wt$r+tddddtdgtjYyt$rq}tjjj!|j#d|_|j&s!|j(s|xj*dz c_d}~wwxYw) NTzinfinite generator detectedz}Dynamo traced the YIELD_VALUE bytecode too many times. This could mean that we have attempted to trace an infinite generator.zLIf you are sure that your generator is not infinite, please report a bug at .rzA Skipping frame due to graph break in a generator's next() call.)r_is_generator_exhaustedr" StopIteration inline_call_rrrr$PT2_ISSUE_TRACKER_URLrrZr%r_rO eval_frame skip_coder skip_frame one_graphrGro)rzrrrls r\ next_variablez*LocalGeneratorObjectVariable.next_variables##  ' ' ) $]B 7 &&( (  )-F &G%  5Iccxbyyz{&11   MM $ $ . .t}} ?AL<<(?(?^^   s(> C? A4C?C?A,C::C?rErc||jjvrtjdStjdSNTF)r*__dict__r@rrzrrs r\rz-LocalGeneratorObjectVariable.call_obj_hasattrs= 4##%.. .#**40 0&&u--r[cyrrZrs r\has_unpack_var_sequencez4LocalGeneratorObjectVariable.has_unpack_var_sequencerr[cyrrZrs r\has_force_unpack_var_sequencez:LocalGeneratorObjectVariable.has_force_unpack_var_sequencerr[cBg}|j||j|Sr)force_apply_to_var_sequenceappend)rzrrs r\rz6LocalGeneratorObjectVariable.force_unpack_var_sequences")+ ((V]]; r[rcj ||j|#t$rt|YywxYwr)rr!r)rzrrs r\rz8LocalGeneratorObjectVariable.force_apply_to_var_sequence&s@ 4%%b)*- )"- s 22FcyrrZrs r\rz=LocalGeneratorObjectVariable.should_allow_nested_graph_breaks1rr[excc|j} |j|y#t$r}|j|Yd}~yd}~wwxYwr)r_raise_exception_variablerexception_handler)rzrrrrls r\_setup_exceptionz-LocalGeneratorObjectVariable._setup_exception4sE## (  , ,S 1  (  $ $Q ' ' (s A?AcT|jduxs|jjdk(S)Nr)rinstruction_pointerrs r\_is_generator_just_startedz7LocalGeneratorObjectVariable._is_generator_just_started?s*!!T)XT-?-?-S-SWX-XXr[c0t|jddS)NrF)rrrs r\rz4LocalGeneratorObjectVariable._is_generator_exhaustedBst))+@%HHr[rch|dk(r|j|S|dk(r|S|dk(rk|jr-t|r"td|Dst t ||j }|j||j|S|dk(r|j }|js|jrd|_ tjS |j|tjtdtj dk\r0|j"j$d k(rd|_ tjS |j|rt t(|n|d k(r|j } |j|t|d k(r|d n|d |j|}t1dt2fi} |j|tj|d|j|t t(||St6|q||||S#t&$rd|_ tjcYSwxYw#t&$rd|_ tjcYSt*$r|j,J|j,cYSwxYw#t.$rwxYw#t5|$rY|SwxYw)N__next____iter__sendc3<K|]}|jywr)is_constant_nonerrhs r\rz;LocalGeneratorObjectVariable.call_method..XsBc3//1BrcloseTrZ)r CALL_INTRINSIC_1throwrr9r__InternalThrowException)rr%rrr"rr push_manyrrrr?r"ExceptionVariable GeneratorExitr version_infonext_instructionopnamer rSr!symbolic_resultrrrXrrr) rzrrrrrretvalexc_typer s r\rz(LocalGeneratorObjectVariable.call_methodEs : %%b) ) Z K V^..0SYBTBB,Y;''F   T "%%b) ) W_''F..0D4P4P4R-1* 777 8%% 33M2F($$///66:LL15F.$;;; .%%b),\2>W_''F  %%bSY!^$q'aQ ''+F|6 bIH ?%%b)*E*EhPR*ST""2& )v>Mw"2tT6::a) 8-1* 777 8) 8-1* 777, . --999---  .,%  N1: M  sIA,H!!I:(J7J! II J)"J J JJ10J1rrBr]N)'rWrXrYrrrrrr~rrrrrrrr__repr__rrrr*r>rr@rrrrrrrr rr"r%rrrrs@r\rrs +nn +S> +@ +  +  +%..+c+'#'2e2$#??HV$T#s(^#T# ;B.).14. .*Ad0GD- o -3;_>** *4& &tww%%r[c6|jjSr)rCrrs r\rz'LocalGeneratorFunctionVariable.get_code%ww!!r[c6|jjSr)rCrrs r\rz*LocalGeneratorFunctionVariable.get_globals(sww""$$r[c6|jjSr)rCrrs r\rz'LocalGeneratorFunctionVariable.has_self+rHr[rrFrrDc8ddlm}|j||||S)Nr)rD)rrDbuild_inline_tracer)rzrrrrDs r\_build_inline_tracerz3LocalGeneratorFunctionVariable._build_inline_tracer.s* Q@,@@       r[rEct|jjs2tdt |jjdddg|j |t ||}|jj}|jj}|j||||jS)Nz'non-generator contextlib.contextmanagerzvCannot compile function decorated with `@contextlib.contextmanager` that is not a generator, i.e. does not use `yield`z5Use `yield` in the function body instead of `return`.z2Remove the `@contextlib.contextmanager` decorator.rr ) rrCrr$rrMrrrBr)rzrrrrr{rs r\rz,LocalGeneratorFunctionVariable.call_function=s DGG,,./ ADGG,,./.LH 11"d4j&I ww!GG'') !!   ;; "  r[)rWrXrYrrrrrr~rrFrrrrrrrrr>rMrrrrs@r\rArA s; + $ + +  +  +&&& "%.."%T#s(^%"$"  '  ?#  S/)*  )   # ' S/)*    r[rAc\eZdZdZdededdffd Zddd eede e efdd ffd Z xZ S) 3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager rCrr]Nc 2t||fdti|y)NrB)rr~r?)rzrCrr s r\r~zrrrMrrs@r\rPrP\sb  3 s t  '?#S/)*  2 r[rPc eZdZdZ ddedefdededzdeddf fd Zde fd Z de efd Z de ejfd Zd ddeedee efdeffd Zd dde deffd ZxZS)r0z$Some unsupported user-defined methodNr.rr1rr]c t|dd|i|||_||_|3|j d!t |j dd|_yyy)Nrr__func__rZ)rr~rr1rr()rzrrr1rr s r\r~zUserMethodVariable.__init__s^ )B)&)"  H!5!A' 8(t j4|jj||jg||S|j&rQt#|jj6|jj*} t9|| |j;||St< |)|||S) Nr)is_leaf_functionis_nonstrict_trace_callablerKrXrz torch.nn.ztorch.nn.utils.parametrize)constant) trace_rulesr_r`rrrr[r_r\r]r LEAF_FUNCTIONris_root_tracerrrNNModuleVariabler startswithrrrWrrAFSDPParamGroupuse_training_stateTorchCtxManagerClassVariabler r^rr) rzrrrr_r` call_argsvar module_attrrr s r\rz UserMethodVariable.call_functions P &tww /2$..*2T2I88ioo>>NNC$$RF; ; DGG $2$..*2T2I88ioo>>LLC$$RF; ; 99 # # %* HHi00+ "$''<rrr1rrDrzrrr s r\rDzUserMethodVariable.var_getattrsM : 88O : #((TWWdnnE Ew"2t,,r[r)rWrXrYrrrr>rr~rr=rrrrr]r*rrrrDrrs@r\r0r0s. $( J S#X JJD= J  J  J2C#C40 T%"2"23 B7 #B7'B7S/)* B7  B7H-5-S-_--r[r0cdeZdZdedddeddffd Zdd d eedee efdeffd Z d d Z xZ S)WrappedUserMethodVariablewrappedrrGrr]Nc |jdd|jddt||j|jfi|||_||_y)Nrr)rrr~rrrqrrzrqrrr s r\r~z"WrappedUserMethodVariable.__init__sK  4 5$ W[[;F;  r[rrErc|jj|t| |||}|jj ||Srrenterrrexitrzrrrrr s r\rz'WrappedUserMethodVariable.call_functionA 2&r48 " r[cjfdjjtddy)Nc(jSrrrrzsr\z7WrappedUserMethodVariable.reconstruct.. gdll&;r[r9F add_push_nullrq extend_outputrrzrs``r\rz%WrappedUserMethodVariable.reconstruct 4;< 21e<=r[r<) rWrXrYr0rr~rr>rrrrrrs@r\rprpsm # +      # ' S/)*   >r[rpcdeZdZdedddeddffd Zdd d eedee efdeffd Z d d Z xZ S)WrappedUserFunctionVariablerqrrGrr]Nc z|jddt||jfi|||_||_y)Nr)rrr~rrqrrss r\r~z$WrappedUserFunctionVariable.__init__s7  4 .v.  r[rrErc|jj|t| |||}|jj ||Srrurxs r\rz)WrappedUserFunctionVariable.call_functionryr[cjfdjjtddy)Nc(jSrr|r}sr\r~z9WrappedUserFunctionVariable.reconstruct..)rr[r9Frrs``r\rz'WrappedUserFunctionVariable.reconstruct(rr[r<) rWrXrYrrr~rr>rrrrrrs@r\rrsm % +      # ' S/)*   >r[rcdtdtfd}|Dcgc] }|| }}|jDcic]\}}|||}}}||i|} |jj | |t |Scc}wcc}}w)Nxr]cv|jrtd|jS|jS)NrL) is_tensorr get_real_valuer")rs r\convertz-invoke_and_store_as_constant..convert5s1 ;;=(!,;;= =##%%r[r )r>rrrregister_attr_or_moduler+) rrrrrrrrrress r\r^r^.s&?&s& !% %1GAJ %D %(.  71am 7F 7 d f C 99 , ,  d# -  & 7s A>BcReZdZdhejZ d%dededeeefdedzdedzdedzdedzd edzd ed dffd Z d e efd Z d e jfdZd e jfdZd ee jfdZd%deedzd e jfdZd efdZdeed e jfdZdddeded efdZdddedeed eeefd ef fd Zd efdZddded effd Zddded effd Zd efd Z d eeeffd!Z!d"ddeed eeefd eeeffd#Z"d&d$Z#xZ$S)'rrNrpr{rrrr wrapped_fnrr]c  | jd| jtt |di| t |j tsJt |j tjsJt |tsJ||_ ||_ ||_ ||_||_||_||_||_y)N mutation_typerrZ)rupdater;rr~rr"rrrrrpr{rrrrrr) rzrpr{rrrrrrrr s r\r~z#NestedUserFunctionVariable.__init__Js ::o & . MM(<(>M ? "6"'446<<<$113U^^DDD)T***  "  $& 2<r[cgSrrZrs r\rz$NestedUserFunctionVariable.self_argsgrr[c"|jSr)rrs r\r"z-NestedUserFunctionVariable.as_python_constantjs  ""r[c6|jjSr)r{r"rs r\rz#NestedUserFunctionVariable.get_codemsyy++--r[c"tjSrr)rs r\r*z&NestedUserFunctionVariable.python_typepr+r[ _convertingc ddlm}t|}| t}||vr t d|j | |j ||j|S#|$r}t d|d}~wwxYw#|j|wxYw)Nr9)r:z-cycle detected in mutually recursive closuresz1failed to convert closure cell to Python constant)baser:idsetrVadd_get_function_impldiscard)rzrr:self_idrls r\rz'NestedUserFunctionVariable.get_functionss >T(  %K k !(?    )**;7    ( 3 (C      (s#A!!A7& A22A77A::B cP |jy#ttf$rYywxYwr)r"rr%rs r\rz-NestedUserFunctionVariable.is_python_constants-   # # %#[1  s %%cd}|jrddlm}|j}g}|jjD]}|j j j|}||ur tdt|tr|j|}n|j}|jt|t|}t!j"|j$j|j&|j(jd|} |j*r|j*j| _|j.r|j.j| _|j2rZ|j2j} t| trddlm} t9| | } t| t8sJ| | _| S)Nr)rEz self-referential nested function)argdefsrr)rrrE current_txrrr load_cellrVrrrr"rr8rrrr{rrprrrrrrrrr) rzr closure_cellsrErcellsr=r4r rfrrs r\rz-NestedUserFunctionVariable._get_function_impls << L1&113BE LL.. /!# 6 6 @ @ J !D(01STTm-GH)66{CE)<<>E Yu-.- /."%LM!! II ( ( * NN LL + + -!   == $ @ @ BD  ??"&//"D"D"FD    **==?K+u-."8K#89 k40 00#.D  r[rrEname_varrcp|jjj||j|tSr)rr store_attrr r?)rzrrrs r\ call_setattrz'NestedUserFunctionVariable.call_setattrs* ))$D%%r[rrcj|dk(r|j|g|St| ||t||S)N __setattr__)rrrrrzrrrrr s r\rz&NestedUserFunctionVariable.call_methods? = $4$$R/$/ /w"2tT$Z@@r[c|jduSr)rrs r\ has_closurez&NestedUserFunctionVariable.has_closures||4''r[c|dk(r|jS|dk(r|jS|dk(r!t|dd}|r|jSdSt|||S)NrWrirr)rrrr"r const_getattr)rzrrdr s r\rz(NestedUserFunctionVariable.const_getattrsi : ==? " : ==? " > !j$/A-.1'') 8D 8w$R..r[c|dk(r)tjjt|dS|dk(r)tjjt|dSt|||S)Nrir{rr)rr@rrrrrns r\rz+NestedUserFunctionVariable.call_obj_hasattrsc : --44WT65JK K > !--44WT:5NO Ow'D11r[cyrrZrs r\rz#NestedUserFunctionVariable.has_selfrr[c|jSrrrs r\rz&NestedUserFunctionVariable.get_globalsrr[rcH|j}tj||j|jj |j rt|j jndtdtt|jjD}|jr|jj|_tj |j"|i|}|j%t'|j(j}t+|j,j.|t1|||t3|jD])\}} | |vsJ|j4j|} | || <+|S)Nc32K|]}tdywr)r8)r_s r\rz7NestedUserFunctionVariable.bind_args..sSa)D/Ss)rrrrrpr"rrrrrr7rkeys_as_python_constantrrrTrUapply_defaultsrrVrrr6rrr) rzrrrr{rfrNrrrr<s r\rAz$NestedUserFunctionVariable.bind_argssJ }}!!  NN LL + + -*.--E$--%% &T S5T]]_5P5P1Q+RS S   ??"&//"I"I"KD ,!!$',,d=f= eoo++-...7ffd+"4#3#34 ICv% %%<<%%c*DF4L  r[cHjfd|jjj|jgt j |jjj|jr|jn!jjdg|jr|jn!jjdg|jr|jn!jjdg|jr= |jj}jj|gn!jjdgjt!dd|j"rvjfd|j"jt!ddjt%djt!ddj&}|j(j*j-|r}|j(j*j.|j1D]H\}}j3|jt%dj5|Jyy#t$r|jYjwxYw)Nc0jtdS)Nr)load_import_fromrWrsr\r~z8NestedUserFunctionVariable.reconstruct..sG,,X7JKr[Fc(jddS)N functoolswrapsrrsr\r~z8NestedUserFunctionVariable.reconstruct..;s00gFr[r9rT)rr{rcreate_load_const_uncheckedrr@rr rrcreate_load_constrrrr"rrrrrrrhas_pending_mutationstore_attr_mutationsrdup_topr)rzrrrrr s ` r\rz&NestedUserFunctionVariable.reconstructsv K   wBB4>>RST '' (?(?@A == DMM "  ! !7#<#rrrr~rrrrr"rrrr*rrrrrrrrrrrr@rrrrArrrs@r\rrDs_ ! 0 0N .2= ==S> = "D( = $d* =%t+=!4'=$d*== =:40#E$6$6#.%..."T%"4"45")C4)5CUCU),D6c#h65;M;M6p& #&"& &  & A # A A' A S/)* A  A(T(/ 7/s/s/2)2142 2$T#s(^''S/)*  c?" # :6)r[rcdeZdZdedddeddffd Zdd d eedee efdeffd Z d d Z xZ S)!WrappedNestedUserFunctionVariablerqrrGrr]Nc |jdd|jdd|jdd|jdd|jdd|jdd|jdd|jddt| |j|j|j |j |j|j|j|j||_ ||_ y) Nrpr{rrrrrr) rrr~rpr{rrrrrrrqrrss r\r~z*WrappedNestedUserFunctionVariable.__init__Os  9d# 64  ;% :t$ <& =$' 9d# <&  OO LL             OO      r[rrErc|jj|t| |||}|jj ||Srrurxs r\rz/WrappedNestedUserFunctionVariable.call_functionjryr[cjfdjjtddy)Nc(jSrr|r}sr\r~z?WrappedNestedUserFunctionVariable.reconstruct..vrr[r9Frrs``r\rz-WrappedNestedUserFunctionVariable.reconstructurr[r<) rWrXrYrrr~rr>rrrrrrs@r\rrNsm++   6  # ' S/)*   >r[rc eZdZddhejZddededzdeddffd ZdefdZe dede ddfd Z d d d e ede eefdefd Zd d dedefdZd d dedefdZdefdZdefdZdedefdZxZS)SkipFunctionVariabler reasonNrr]c @t|di|||_||_yr)rr~r r)rzr rrr s r\r~zSkipFunctionVariable.__init__s! "6"  r[c|jSrr rs r\r"z'SkipFunctionVariable.as_python_constants zzr[rctj|ddrW|}|}t|ddr&|j}t |d}t|ddr&|j t jnqtj|r)t|j t jn3t|s(t|j t j|||S)N_torchdynamo_disableF_torchdynamo_orig_callabler ) rrrrr(rr&r isbuiltinr' BUILTIN_MATCHr6)rr rguard_on_sourceguard_on_values r\rz'SkipFunctionVariable.create_with_sources  ! !%)? G%O"N.*FN!/!J!J",#%A#.*FN  & &|'A'A B   u % &++L,F,FG H07 &++L,F,FG H5((r[rrErc *tj|jddrVtj|jdd}tdt |jd|jd|ddg y|jt j jur>|jd }|r|j}td d |d |dd|dg y|jt j jurX|jd }|r|j}nd}tdd|d |dt|jdd|dgdy|jt j jur tddddg yt"j$rEddlm}|j+||j} t-| t.s| j1|||St3|jdd } t3|jd!d} | d"n t | } tj4|j} d#| d$| d%}d&| d'g}d(| vr |d)| d*d+gz }| d9k(rd:}g}|j@r |j@nd;}td| d?||| y#t$r}t|j dd}~wwxYw#t6$rd,d-h}| |vrd.| d| d'}d/d0g}n| \| j9d1rKd2| d| d}d3g}t j j:j=|d4zd4j?|znKd5| d| d6}d7d8g}t j j:j=|d4zd4j?|zY.wxYw)@NrF_torchdynamo_disable_msgz1Skip calling `torch.compiler.disable()`d functionzSkip calling function `z>` since it was wrapped with `torch.compiler.disable` (reason: rJz(Remove the `torch.compiler.disable` callrroz%Call to `torch._dynamo.graph_break()`z0Called `torch._dynamo.graph_break()` with args `z `, kwargs ``z$User-inserted graph break. Message: z.Remove the `torch._dynamo.graph_break()` call.rz$Call to `torch._dynamo.skip_frame()`z/Called `torch._dynamo.skip_frame()` with args `z`. Skipping frame rz#User-inserted skip frame. Message: z-Remove the `torch._dynamo.skip_frame()` call.T)rrrrrz*Call to `torch._dynamo.step_unsupported()`zUser-inserted step_unsupported.z3Remove the `torch._dynamo.step_unsupported()` call.r9SourcelessBuilderrYzrXzz?Dynamo developers have intentionally marked that the function `z ` in file `z` should not be traced.zAvoid calling the function `z`.rOz:Apply `@torch._dynamo.dont_skip_tracing` to the function `zw` to force tracing into the function. More graph breaks may occur as a result of attempting to trace into the function.z Please file an issue to PyTorch._abc _warningsz6Dynamo does not know how to trace the Python builtin `zIf you are attempting to call a logging function (e.g. `_warnings.warn`), you can try adding it to `torch._dynamo.config.reorderable_logging_functions`.zKPlease file an issue on GitHub so the PyTorch team can add support for it. rz*Dynamo cannot trace optree C/C++ function zi Consider using torch.utils._pytree - https://github.com/pytorch/pytorch/blob/main/torch/utils/_pytree.py z/Dynamo does not know how to trace the builtin `z.` This function is either a Python builtin (e.g. _warnings.warn) or a third-party C/C++ Python extension (perhaps created with pybind).zIf it is a Python builtin, please file an issue on GitHub so the PyTorch team can add support for it and see the next case for a workaround.aIf it is a third-party C/C++ Python extension, please either wrap it into a PyTorch-understood custom operator (see https://pytorch.org/tutorials/advanced/custom_ops_landing_page.html for more details) or, if it is traceable, use `torch.compiler.allow_in_graph`.allow_in_graphzFound an allow_in_graph decorator to a function which is created inside the parent function that is getting compiled. This is not supported for now.zz,Attempted to call function marked as skippedzmodule: z , qualname: z, skip reason: )!rrr r$rr_rO graph_breakrr"rrf_codestep_unsupportedr%r#rordont_skip_tracingbuilderrrrrrrgetfilerrfr` warn_oncejoinr)rzrrrrograph_break_msgskip_frame_msgrlr rebuilt_fnqualname module_orrpathrrknown_python_builtin_modulesrs r\rz"SkipFunctionVariable.call_functions>  ! !$**.De L((5OQUVC KDJJ5djj\B::=aA?  ZZ5==44 4$jj/O"1"D"D"F ?J4&P[\b[ccdeB?BSTD  ZZ5==33 3#ZZ.N!/!B!B!D!# >I${[aZbc""3BII">!?qBA.AQRC  ZZ5==99 9 7H AM ''6/55b$**E !*.BC%33BfEEtzz>;OPH L$?I090A,s9~K8 Ytzz2UV^U_` $v%<> 38*B? D(TU]T^_ll; EX++? $(KKT[[5GF F";-|H:_U[T\]'  a 7%aee,$6 7B% Y06 /D, <<'=(27 iGE *y/C/CH/M$N{m[\]e\ffg"hK^E MM''11+2DtyyQVGW2WXJ+VWX`Wabab m;EMM''11+2DtyyQVGW2WXK% Ys+J%>K K(J>>KCNNrchtjjt|j|Sr)rr@rrr rs r\rz%SkipFunctionVariable.call_obj_hasattr3s&))00T1JKKr[c|tvrtj||St||j|j |Sr)r3rrCrr rrs r\rDz SkipFunctionVariable.var_getattr8s7 ) ),,T48 8b$**dkk4@@r[cyrrZrs r\rz'SkipFunctionVariable.is_python_hashable>rr[c,t|jSr)rr rs r\rz$SkipFunctionVariable.get_python_hashAsDJJr[rcht|txr!|j|jk(Sr)rr>r"rs r\rz$SkipFunctionVariable.is_python_equalDs1 uo . H'')U-E-E-GG r[r)rWrXrYr>rrrr~r"rrrrrrr@rrDrrrrrrrrs@r\rr{s'  ' 'N c3:PT C)s)F)?U))4L #L'LS/)* L  L\L)L14L L A5ASA_A D   V  r[rcdeZdZdedddeddffd Zdd d eedee efdeffd Z d d Z xZ S)WrappedSkipFunctionVariablerqrrGrr]Nc |jdd|jddt||jfd|ji|||_||_y)Nr r)rrr~r rrqrrss r\r~z$WrappedSkipFunctionVariable.__init__LsN  7D! 8T" Hw~~HH  r[rrErc|jj|t| |||}|jj ||Srrurxs r\rz)WrappedSkipFunctionVariable.call_functionXryr[cjfdjjtddy)Nc(jSrr|r}sr\r~z9WrappedSkipFunctionVariable.reconstruct..drr[r9Frrs``r\rz'WrappedSkipFunctionVariable.reconstructcrr[r<) rWrXrYrrr~rr>rrrrrrs@r\rrKsm % +      # ' S/)*   >r[rceZdZdZdedededdffd Zdd d edeffd Zde efd Z dd d e ede eefdefdZ xZS)WrapperUserFunctionVariablea3 Used to represent a wrapper object that contains the actual callable as an attribute. For example, torch.jit.script/trace have the original function at their _torchdynamo_inline attribute. Similarly, functions with __script_if_tracing_wrapper have the original attr at "__original_fn". wrapper_obj attr_to_tracerr]Nc @t|di|||_||_yr)rr~rr)rzrrrr s r\r~z$WrapperUserFunctionVariable.__init__qs# "6"&*r[rrErc||jk(r[t|j|j}|jxrt |j|}t j |||St|!||Sr) rrrrr(r>rrrD)rzrrrrr s r\rDz'WrapperUserFunctionVariable.var_getattrvsi 4%% %$**D,>,>?C[[BZ T%BF"((S&9 9w"2t,,r[cgSrrZrs r\rz%WrapperUserFunctionVariable.self_args~rr[rc t|jdrt|j|jd}t|ddxsd}|j ddddk7r|j }t jj|j}|j}d |d |d djtj|g} tjj j#| tjj j$j'd } | j)t$j*rtj,j.j1} t3| z} | d j| d jf} djtj| } d| dd | dd}|t5| z }| j7||j9t;|z}t=j>t@jBjE||t=jF|jg||S)N cache_inforXrrr9)maxsplitrr_zGDynamo detected a call to a `functools.lru_cache`-wrapped function at ':z'. Dynamo ignores the cache wrapper and directly traces the wrapped function. Silent incorrectness is only a *potential* risk, not something we have observed. Enable TORCH_LOGS=+dynamo for a DEBUG stack trace. This call originates from: z torch._dynamoz)call to a lru_cache wrapped function at: r)$rrrrsplit frame_summaryosrbasenamefilenamelinenor traceback format_listr_rOr`rlogging getLogger isEnabledForDEBUG_guardsTracingContext extract_stackrrdebugrrrrrgetattr_and_tracerr@)rzrrr target_fnrrrrro dynamo_logger user_stack frame_locuser_stack_formatteduser_stack_traceall_argss r\rz)WrapperUserFunctionVariable.call_functions 4##\ 2 0 0$2D2DdKI!)\2>D"K  q 1!4? " 0 0 2 77++M,B,BC&--$$,:Qvh73 wwy44m_EFGI ##--c2 % 3 3 ; ; E Eo V  --gmm>#d4j0--  ' ' -  9--d.@.@A MH M   r[)rWrXrYrrrr~r>rDrrrrrrrs@r\rris+C++s+t+ -5-S-_-40, #, ', S/)* ,  , r[rc JeZdZdZdededededdf fd Zdeefd Z xZ S) WrapperUserMethodVariablez Similar to WrapperUserFunctionVariable, but for methods. The only delta is saving the vt for `self` object of the method which is then used by WrapperUserFunctionVariable in `call_function` method. rrself_objrr]Nc 6t|||fi|||_yr)rr~r)rzrrr+rr s r\r~z"WrapperUserMethodVariable.__init__s  m>v>r[c|jgSrrZrs r\rz#WrapperUserMethodVariable.self_argsr[r[) rWrXrYrrrr>r~rrrrs@r\r*r*sN "     40r[r*cRtjjrddlm}|SiS)Nrtraceable_collective_remaps)r_ distributed is_available)torch.distributed._functional_collectivesr0r/s r\_traceable_collective_remapsr4s& %%' +* Ir[ctjjsJd|tj vsJ|j }|j d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)r_r1r2r4valuesrW import_sourcer()rr inner_name path_sources r\_traceable_collectives_sourcer:sd    ) ) +B-BB + -/668 88 8J""#NOK k: ..r[c eZdZdZdedefdededdffd Zed d d edefd e d eddf dZ edede fdZ ed d dedefde eeffdZd d deedeeefdefdZxZS)!CollectiveFunctionRewriteVariablea Some of the torch.distributed.* collective APIs are possible to rewrite to 'traceable' collectives. This class provides both a way to check if a function is remappable, and perform the remapping. In the case that a function is 'remappable' but only for some combinations of call-time arguments, we check the args at `call_function` time and fall back to graph-breaking if needed. This is no worse than status-quo as we currently graph-break on all distributed.* collectives. r.replacement_varrr]Nc Xt||fi|t|tsJ||_yr)rr~rrr=)rzrr=rr s r\r~z*CollectiveFunctionRewriteVariable.__init__s0 &v&/+?@@@.r[rrEold_fnroptionsc jtj||\}}t|ft|fd|i||d|S)Nr)r=r)r<rwr)rr?rr@new_fn new_sources r\rz(CollectiveFunctionRewriteVariable.createsO?FFr6R 0  0V VgV    r[variablecHtj|xr |tvSr)r isfunctionr4)rDs r\ can_rewritez-CollectiveFunctionRewriteVariable.can_rewrite s%   x ( WX9U9W-W r[c8t|}|t||fSr)r4r:)rrrBs r\rwz)CollectiveFunctionRewriteVariable.rewrite s$./34R@@@r[rcddlm}ddlm}t j |j }t|j|i|j}d}d|vrQ|djr>td|j d|d|d|j gtj |j |j|j|j fvro|j#d }| |j$n|j&d j(}||vrt+d |t,j.j1|||d <|j2j5|||S) Nr)REDUCE_OP_TO_STRrZasync_opz)async_op=True for distributed collectivesz, args= , kwargs=z3`torch.compile` doesn't support `async_op=True for ropzUnsupported all_reduce op: )torch.distributedr1r3rJrrTrrrUrVr"r$r SUPPORTABLE all_reducereduce_scatter_tensor_reduce_scatter_baserr  parametersdefaultr9rr@rr=r) rzrrrdistrJrT reduce_op_var reduce_ops r\rz/CollectiveFunctionRewriteVariable.call_function sj )N%%dgg. ninnd5f5??@  F:$6$I$I$K C77)8dWJvi8QRVRYRYQZ[&22   77 OO  & &  % %   #JJt,M!,##))$/77   00 #>yk!JKK$55<< +F4L##11"dFCCr[)rWrXrYrrrrr~rrrrrGrr(rwrr>rrrrrs@r\r<r<s+ / S#X  /. /  /  /  #  c"      -     c d  A #A)1#s();A sJ AA -D #-D'-DS/)* -D  -Dr[r<c@eZdZdddeedeeefdeffd ZxZS)FunctoolsWrapsVariablerrErrr]c|s5tdk(r'dtdtffd }tj|St |||S)Nr9rr]ct|tjr|jdSt d|dgt j y)Nr)rzfunctools.wrapsz]`torch.compile` can't trace `functools.wraps` on functions defined outside the compile regionr)rrrcloner$rrO)rrs r\rz3FunctoolsWrapsVariable.call_function..wrapsF sNb)"F"FG88tAw877-!d *66 r[)rrr>rLambdaVariablerr)rzrrrrr s ` r\rz$FunctoolsWrapsVariable.call_function> sL #d)q. # / ++E2 2w$Rv66r[) rWrXrYrr>rrrrrs@r\rYrY= sB7 #7'7S/)* 7  77r[rYc@eZdZdefdZdddeedeeefdefdZ y) CollectionsNamedTupleFunctionr]c|jSrr%rs r\r"z0CollectionsNamedTupleFunction.as_python_constantX r&r[rrErrc ,t||}|r~ |j|Dcgc]}|jc}i|jDcic]\}}||jc}}}tjtStdd|d|dgt j"ycc}wcc}}w#t$rL} t t | |tttj| jYd} ~ d} ~ wwxYw)N)rrznamedtuple constructionzargs=rLz?`torch.compile` only support certain input types for namedtupler)r1rr"rrr"rrmapr@rrrUserDefinedClassVariabler=r$rrO) rzrrr constant_argsrrrr rs r\rz+CollectionsNamedTupleFunction.call_function[ s ,D&9  6:;a**,;=C\\^LTQq!..00L55.0  -tgZy)Y"..  <L (Ic"2"9"9388DE s4B>B3B> B8(B>3 B>> DADDN) rWrXrYrr"rr>rrrrZr[r\r_r_W sHC # ' S/)*    r[r_c eZdZdhejZ ddedeedeeefdededdf fd Z de fd Z dd Z defd Z d d deedeeefdefdZd d dedefdZd d dedefdZdefdZdefdZdefdZdefdZdedefdZxZS)FunctoolsPartialVariableoriginal_cache_hashNrfrkeywordsrr]c t|di|||_t|tsJ||_t|t sJ||_tjt|_ ||_ yr) rr~rfrrrrrhrpartialr4 fake_valuerg)rzrfrrhrgrr s r\r~z!FunctoolsPartialVariable.__init__ sf "6" $%%% (D)))  $++H5#6 r[c"tjSr)rrjrs r\r*z$FunctoolsPartialVariable.python_type s   r[c<jfd|j|jrj|j|js2j t t|jdzdyj|jjt|jj}j jt|t|jzdz|dy)Nc(jddS)Nrrjrrsr\r~z6FunctoolsPartialVariable.reconstruct.. sg&>&>{I&Vr[r9F) rrfrforeachrhrrrr6rkeyscreate_call_function_kw)rzrrps ` r\rz$FunctoolsPartialVariable.reconstruct sVW  99 OODII &}}  ! !"6s499~7I5"Q R  ,,./T]]'')*  + +CIDII,F,JDRW X r[c"|jSrr"rs r\rz%FunctoolsPartialVariable.get_function &&((r[rrEc|jt|z}i|j|}|jj |||Sr)rrrhrfr)rzrrr merged_args merged_kwargss r\rz&FunctoolsPartialVariable.call_function sB ii$t*, 34==3F3 yy&&r; FFr[rctjjtt j t |Sr)rr@rrrrjr4rs r\rz)FunctoolsPartialVariable.call_obj_hasattr s2))00 I%%h/ 6  r[c|jxrt|j|}|dk(r |jS|dk(r!tj|j |S|dk(rW|j jDcic]\}}tj||}}}tj||S|tvrtj||Stt|ycc}}w)Nrfrr rh)rr(rfrrKrrhrr@rConstDictVariabler3rCr"r)rzrrrrrrs r\rDz$FunctoolsPartialVariable.var_getattr s>DKK!> 6>99  6>))$))FC C : ?C}}?R?R?TUtq!%,,Q/2UEU..uVD D ) ),,T48 8 4 Vs> C'c :tj|jjg|jDcgc]}|jc}i|j j Dcic]\}}||jc}}Scc}wcc}}wr)rrjrfr"rrhr)rzrhrrs r\r"z+FunctoolsPartialVariable.as_python_constant s  II ( ( * 26)) <3c$$& < 6:]]5H5H5JKTQq!&&((K  <Ks B 1Bc xtj|jjg|jDcgc]}|jc}i|j j Dcic]\}}||jc}}}|j|j|_|Scc}wcc}}w)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constants) rrjrfguard_as_python_constantrrhrrg cache_hash)rzrrrs r\r}z1FunctoolsPartialVariable.guard_as_python_constant s"" II . . 0 48II >qa((* > <@==;N;N;PQ41aq!,,..Q   # # / $ 8 8F  ?Qs B1 1B6c|jjxrHtd|jDxr*td|jj DS)Nc3<K|]}|jywrrr-s r\rz>FunctoolsPartialVariable.is_python_hashable.. sBC**,Brc3<K|]}|jywrrrr s r\rz>FunctoolsPartialVariable.is_python_hashable.. sS5E,,.Sr)rfrrrrhr6rs r\rz+FunctoolsPartialVariable.is_python_hashable sP II ( ( * TB BB TSDMM. s@sS((*@rc3<K|]}|jywrrrs r\rz;FunctoolsPartialVariable.get_python_hash.. sS5u,,.Sr)rfrrrhr6r)rz func_hash args_hash values_hashs r\rz(FunctoolsPartialVariable.get_python_hash sQII--/ @dii@ SDMM. s'"UE%%e, c3DK|]\}}|j|ywrr)rvalue_avalue_bs r\rz;FunctoolsPartialVariable.is_python_equal.. s'&Wg''0r) rrfrfrrrrrhr6rs r\rz(FunctoolsPartialVariable.is_python_equal s u6 7  ))%**5 &)$))UZZ&@  *-MM((*ENN,A,A,C+ r[rr<)rWrXrYr>rrrrrr~rr*rrrr@rrDr"r}rrrrrrrrs@r\rfrf} sE  ' 'N$( 77'7sO+, 7 ! 7  7 7(!T!  )c)G #G'GS/)* G  G ) 14   55 5S 5_ 5 C  #  D ;;  V  r[rfc `eZdZdddhejZeejdee de fe jffdZ ede deddfd Zded e dd ffd Zede de ffd ZdefdZde fdZdddeed eeefdefdZdddedeed eeefdef dZde fdZxZS)PolyfilledFunctionVariablerr traceable_fnr].ciSrrZ)rs r\_get_polyfill_handlersz1PolyfilledFunctionVariable._get_polyfill_handlers s  r[r rcft|jtj|||Sr r rs r\rz-PolyfilledFunctionVariable.create_with_source s* f'' (B(BCD5((r[rNc .t|di|||_|jj ||}d}t |s Jd|d|dD]"}t ||d}|st |sJ|}ntd|d||_||_ y)NzPolyfill handler z is not callable for )__torch_dynamo_polyfill____python_implementation__z# does not have a traceable functionrZ) rr~rrrcallablerrSrr)rzrrhandlerrcandidate_attr candidater s r\r~z#PolyfilledFunctionVariable.__init__ s "6"--/33B;  X$5gY>STVSW"XX  N >I ***(  #G9,OP " ,r[c|jSr)rrs r\ polyfill_fnz&PolyfilledFunctionVariable.polyfill_fn, s   r[c0t|jddS)N*__torch_dynamo_can_constant_fold_through__F)rrrs r\can_constant_fold_throughz4PolyfilledFunctionVariable.can_constant_fold_through0 s OOI5  r[c"|jSrrsrs r\rz'PolyfilledFunctionVariable.get_function5 rtr[rrErc "|jrt||rt|j|Dcgc]}|jc}i|j Dcic]\}}||jc}}}t j ||S|jtjur t|dk(r|st|dtjtjfrtd|djDrtjj!||j"j%dt&j(t+d|djDfit'j(|djDcgc].}|j-r|jn |j.0c}St j ||j0}|j3|||Scc}wcc}}wcc}w)Nr9rc3K|]h}|jxrt|jtxs2t|tj xr|j tujywr)rrr"rrSymNodeVariabler*)rrs r\rz;PolyfilledFunctionVariable.call_function..O se%%'SJq7K7K7Ms,SYq)";";<WTWAWYsA.A0rc3<K|]}|jywr)as_proxy)ras r\rz;PolyfilledFunctionVariable.call_function..Z s?A1::<?r)sym_num)rr2rr"rr>rbuiltinssumrrrrK TupleVariablerrrr create_proxyr_sym_sumrrrrr) rzrrrrrrrtraceable_function_variables r\rz(PolyfilledFunctionVariable.call_function8 s  ) ) +0M &1 6:;a**,;=C\\^LTQq!..00L  #((V4 4 GGx|| #D Q47Y%;%;Y=T=T$UVa ,,33 &&#MM?a??A   "&a   !335002!"+ 4 ('6&;&;B@Q@Q&R#*88T6JJO<L4sHH3H rc>|dk(r|j|||St|j|d}|s't|st |d|d|ji}|j rt |j ||d<t|fi|}|j|||S)N__call__zCannot find callable z in r)rrrr5r<rr(r)rzrrrrmethodr@polyfilled_method_variables r\rz&PolyfilledFunctionVariable.call_methodl s : %%b$7 7$-+f- 'rrrcacherrrrrrrrrMr~propertyrrrrrrrrrr"rrs@r\rr s{   ' ' N__tHS#X,>@R@R,R'S))!') %))-2---4!Xc3h/!! 4 )c)2K #2K'2KS/)* 2K  2KhJ #JJ?# J S/)* J  J(Cr[rcleZdZdededdffd Zd dZdddefd Zddd eede e efdefd Z xZ S) SysFunctionVariabler rr]Nc 2t|di|||_yr)rr~r )rzr rr s r\r~zSysFunctionVariable.__init__ s "6" r[rrEcBt|jrG|jd}|j}|j|d}t j ||||g}n/t jt jt jg}t j|S)Nr __traceback__) r exn_vt_stackr;rDr>rrr?r)rzrexnrntbrs r\exc_infozSysFunctionVariable.exc_info s r //"%C,,C_5B$**2s3S"=E000000E &&u--r[c>|j|jdS)Nr9)rrrs r\ exceptionzSysFunctionVariable.exception s}}R &&q))r[rc|jtjur|j|S|jtjusJ|j|Sr)r rrrrs r\rz!SysFunctionVariable.call_function sH :: %==$ $zzS]]***~~b!!r[)rrEr]zvariables.TupleVariable) rWrXrYrr~rr>rrrrrrrs@r\rr spcST .*3** " # "' "S/)* "  "r[r) create_tma_experimental_metadatacreate_tma_stable_metadataTMADescriptorMetadataTritonHOPifierc eZdZdedefdZdedefdZdede fdZ dd de e jjjd ffd Zde d eee fd dde fdZded e fdeedeeefd edde def dZde d edde dedef dZde d eddee fdZdede fdZdddee ddfdZddde deee fd ddd f d!Zy")#DynamoTritonHOPifierror]c(tddd|gy)Nz!triton kernel unsupported featurerz/Encountered triton kernel unsupported feature: rr$)rzros r\raise_unsupportedz&DynamoTritonHOPifier.raise_unsupported s7I#O  r[maybe_callablec.t|ttfSr)rrr)rzrs r\ is_callablez DynamoTritonHOPifier.is_callable s 79MN  r[rc|jSrr)rzrs r\ get_valuezDynamoTritonHOPifier.get_value s yyr[gridrJ.cddlm}t||r|jSt ddt |dgt jy)Nr9)rJz/unsupported grid type for triton hop check_gridz grid type = z;`torch.compile` only supports list-like grid for check_gridr)listsrJrrr$rrrO)rzrrJs r\ check_gridzDynamoTritonHOPifier.check_grid sK+ d, -==? " I&tDzl3Y&22  r[metarrEc|jDcic]%\}}tjj||'}}}|j ||gi}|Scc}}wr)rrr@rr)rzrrrrrmeta_vars r\ call_gridzDynamoTritonHOPifier.call_grid sZIM U1I..55a8!;UU!!"xj"5 Vs*Auser_fnrrrDc\ddlm}|j||}|j|||}|S)Nr9r)rrrr) rzrrrrrDrwrapped_user_functionrs r\call_user_defined_fnz)DynamoTritonHOPifier.call_user_defined_fn s3 / 1 8 8W E&44RvF r[user_objrctddlm}|J||t|j|j |}|S)Nr9)VariableBuilder)rrr( kernel_source_wrap)rzrrrDrrwrapped_user_objs r\wrap_user_defined_objz*DynamoTritonHOPifier.wrap_user_defined_obj sC -~~*  811dV= %/  r[configscn|j|}|Dcgc]}|j}}|Scc}wr)unpack_var_sequencer})rzrrrs r\maybe_unpack_configsz)DynamoTritonHOPifier.maybe_unpack_configs sB--b1DKK26224KKLs2rcd|js|jd|jS)Nz`@triton.heuristics must return constant values because configs can only contain constant values.)rrr})rzrs r\maybe_unpack_heuristic_resultz2DynamoTritonHOPifier.maybe_unpack_heuristic_result s0((*  " "r ..00r[TritonKernelVariablec|jt|dk7r|jdt||j|j |d|j S)Nr9z7Triton kernels should be called with only a single gridr)kernel kernel_idxrr)rrrrrrr)rzrDrs r\ call_getitemz!DynamoTritonHOPifier.call_getitem s\ == $D Q  " "I tH~??**a"//   r[grids combined_argszvariables.ConstantVariablec Vddlm}i}t|jD]D}||}t |t t fs|j||<|j||<F|jDcic]%\}}tjj||'} }}ddl m} m} |jDcic]6\}}t |t r!|j#r||j%8} }}| jDcic](\}}t |t r|j#s||*} }}| j'D]R}|j)}|j+r$|j-r5|j/dt1|dT| j3| }|| t4}|j6j9d| d|j:||||j=d tjdScc}}wcc}}wcc}}w) Nr9)rzr)kernel_side_tabletriton_kernel_wrapper_mutationz.Unexpected argument type for a Triton kernel: rrrZ)rconstant_args_idxrtma_descriptor_metadatar)dictsrzrrpr!TMADescriptorExperimentalVariableTMADescriptorStableVariable to_metadata get_tensorrrr@r*torch._higher_order_ops.triton_kernel_wraprrr>rr"r6rris_symnode_likerrepradd_constant_argsrrrrr)rzrDrrrrzrrrcombined_args_vtrrrdnon_constant_argsrrs r\call_HOPzDynamoTritonHOPifier.call_HOP s# -:<m((*+ 2Aa A57RS./]]_'*#$<<> a  2AN@S@S@U 8<1I & & - -a 0! 3   &++- 1!_-!2F2F2H q##% %  )..0 1q/2q7K7K7M qD  #))+ A AKKMQ%6%6%8&&DT!WIQO .?? N !2D9   * &11%6+B--/   ))   [   s<*H;H-H%N)rWrXrYrrrr>rrrrrr_fxproxyProxyrrrrrr rrrrrrrrZr[r\rr s S U  / d _ 1 eEHHNN "6"(66tVZQUVr[rrErc2tj||||Sr)r call_triton_kernelrs r\rz"TritonKernelVariable.call_functionu s 0BB $  r[rc|dk(rtj||S|dk(rtj||||St|||||S)N __getitem__run)r rcall_runrrrs r\rz TritonKernelVariable.call_method sW = 3@@tL L U]3<? ? r[)rWrXrYrrrr~rr>rrrrrrrrs@r\rrh s  d WW'*TzW9<WHKW W # ' S/)*     ; # ; ;?# ; S/)* ;  ;ssr[rc deZdZdddeedeedededdf fd Zdefd Zd d Zdefd Z xZ S)rdata_ptrzvariables.DataPtrVariabledims block_dims element_sizerr]Nc t|tjsJt|di|||_||_||_||_yr) rrDataPtrVariablerr~rrrr)rzrrrrrr s r\r~z*TMADescriptorExperimentalVariable.__init__ sH(I$=$=>>> "6"   $(r[ct|jDcgc]}|jc}|jDcgc]}|jc}|jjScc}wcc}wr)rrrrr)rzdims r\rz-TMADescriptorExperimentalVariable.to_metadata sW/'+yy 1S\\^ 1'+ 7S\\^ 7    & & (  1 7s A2A7 cjfdjjgjjj }j |jt|dzdy)NcVjddtjdS)Nz$triton.tools.experimental_descriptorcreate_d_tma_descriptor)rrrr}sr\r~z?TMADescriptorExperimentalVariable.reconstruct.. s+G,,6#dii.))9:r[r9F) rrrrrrrorr)rzrrs`` r\rz-TMADescriptorExperimentalVariable.reconstruct sp  !!'*@@T__@d.?.?@c$i!mU3r[c.|jjSr)r from_tensorrs r\rz,TMADescriptorExperimentalVariable.get_tensor s}}(((r[r<) rWrXrYrr>rr~rrrrrs@r\rr si )- )?# )) ) & )  )  ) S  4)O)r[rcPeZdZdddddeddffd Zdefd Zd d Zdefd ZxZS) rrrL block_shaperKrr]Nc d|jsJt|di|||_||_yr)rrr~rr')rzrr'rr s r\r~z$TMADescriptorStableVariable.__init__ s6 !!! "6" &r[cHt|jjSr)rr'rrs r\rz'TMADescriptorStableVariable.to_metadata s!)    % % '  r[cjfdjd|jj|jj dy)Nc(jddS)Nztriton.tools.tensor_descriptorTensorDescriptorrrsr\r~z9TMADescriptorStableVariable.reconstruct.. sG,,0"r[r%r)r load_methodrrr'rrs `r\rz'TMADescriptorStableVariable.reconstruct sT  M* (  !Ar[c|jSr)rrs r\rz&TMADescriptorStableVariable.get_tensor s {{r[r<) rWrXrYrr~rrrrrs@r\rr sK '  '$ ' '  ' S Cr[rcTeZdZdededdffd Zdddeedee efdefd Z xZ S) 'CreateTMADescriptorExperimentalVariablerankrr]Nc >|dvsJt|di|||_y)N)r9rrZ)rr~r1)rzr1rr s r\r~z0CreateTMADescriptorExperimentalVariable.__init__ s( v~~ "6" r[rrErcd|vr|dn|d}t|tjs2tdd|d|d|jdd|jd g |jd k(r]t |t |zd k7r$t |d t |t |zd|vr|dn|d g}d|vr|dn|dg}nvt |t |zdk7r$t |dt |t |zd|vr|dn|d d|vr|dn|dg}d|vr|dn|dd|vr|dn|d g}d|vr|dn|d}t|tjsJt||||S)Nptrrz.invalid ptr argument for create_tma_descriptorzargs = z , kwargs = z#Expected `ptr` argument of `create_z]d_tma_descriptor`to be from a `.data_ptr()` call, represented internally by `DataPtrVariable`z`torch.compile` may fail to internally represent result of `.data_ptr()` with `DataPtrVariable` due to a graph break between the `.data_ptr()` call and `create_zTd_tma_descriptor`. Please ensure there were no graph breaks between these two calls.rr9rOz6TMA metadata rank=1 requires exactly 4 arguments, got r block_dimrz6TMA metadata rank=2 requires exactly 6 arguments, got dim1dim0 block_dim1r block_dim0rr)rrrr)rrrr$r1rr<r)rzrrrr4rrrs r\rz5CreateTMADescriptorExperimentalVariable.call_function s %fUmDG#y889 H!${6(;A$))M__#yyk*//  99>4y3v;&!+$LSQUYY\]cYdMdLef "'&u d1gD(3f'<{#$q'J4y3v;&!+$LSQUYY\]cYdMdLef #)F"2vQ"(F"2vQD )5(>|$DG(4(>|$DGJ2@61Ivn-tTVx #y889990!%   r[) rWrXrYrrr~rr>rrrrrs@r\r0r0 s^  : #: ': S/)* :  : r[r0c4eZdZdddeedeeefdefdZy)!CreateTMADescriptorStableVariablerrErrr]cTd|vr|dn|d}d|vr|dn|d}t||S)Nrrr'r9)rr')r)rzrrrrr's r\rz/CreateTMADescriptorStableVariable.call_function( sF &.%7!T!W/</Ff]+DQRG *#  r[N)rWrXrYrr>rrrrZr[r\r<r<' s<  #  '  S/)*    r[r<c8eZdZdZdddeedeeefdefdZy) !PyTreeGetNodeTypeFunctionVariableaK `torch.utils._pytree._get_node_type` function is very hot function. We want to special case it to reduce Dynamo tracing time. def _get_node_type(tree: Any) -> Any: node_type = type(tree) # All namedtuple types are implicitly registered as pytree nodes. # XXX: Other parts of the codebase expect namedtuple types always return # `namedtuple` instead of the actual namedtuple type. Even if the type # is explicitly registered. if is_namedtuple_class(node_type): return namedtuple return node_type rrErrr]ct|dk7rt|dt|d}|djrMt|djj t j t|dj}|dj}t|r0ttdd}tj|t|Stj|||S)Nr9z6pytree_get_node_type requires exactly 1 argument, got r collectionsrr )rr<rr'rr& TYPE_MATCHr0r*rr(r.r>rr)rzrrr type_sourcer*s r\rz/PyTreeGetNodeTypeFunctionVariable.call_functionF s t9> HT T  7>> $q'..33L4K4KL M$T!W^^4K1g))+ { +$\-%@,OK"((ZE E$$R[IIr[N) rWrXrYrrr>rrrrZr[r\r?r?7 sF J #J'JS/)* J  Jr[r?cDeZdZdZdddeedeeefdeffd ZxZ S) PyTreeTreeIsLeafFunctionVariablea@ `torch.utils._pytree.tree_is_leaf` function is a hot function. We want to special case it to reduce Dynamo tracing time. def tree_is_leaf( tree: PyTree, is_leaf: Callable[[PyTree], bool] | None = None, ) -> bool: if is_leaf is not None and is_leaf(tree): return True return _get_node_type(tree) not in SUPPORTED_NODES When is_leaf is None (the common case), we can optimize by not tracing into the function. When is_leaf is not None, we fall back to regular tracing since it requires executing user code. rrErrr]cvt|dkst|dkDrt|dt||jdt}t|dk(r|d}|j st ||||S|d}ttjjjj ||gi}tj|tjjjt}|j!|d|gi}t#j$|j& S)Nr9rz,tree_is_leaf requires 1 or 2 arguments, got rQrr r)rr<rr?r,rrr?r_r`ra_get_node_typer>rrbrcrr@rr ) rzrrrrQtree node_type_varsupported_nodes_varoutr s r\rz.PyTreeTreeIsLeafFunctionVariable.call_functionl s t9q=CIM >s4ykJ  **Y(>? t9>1gG'')7(T6: :Aw9 KK   . . -TFB '  .33  KK   / /46  "--b.=/SUV&&399}55r[rrs@r\rErE\ sG $6 #$6'$6S/)* $6  $6$6r[rEcXeZdZdZdededdffd Zddd eedee efdefd Z xZ S) SparseTensorCreationSkipVariablezk Skip variable for sparse tensor factory functions with clear messaging regarding lack of support. r rr]Nc .d}t||fd|i|y)Nz8sparse tensor creation is not supported in torch.compilerrr~rzr rrr s r\r~z)SparseTensorCreationSkipVariable.__init__ sK 8v88r[rrErcddlm}t|jdt |j}t dd|d|dg|j y) Nr)rrWz$Sparse tensor creation not supportedz function: zEtorch.compile does not support sparse tensor creation functions like zZ. Sparse tensors require specialized handling that is not yet implemented in the compiler.r)rrrr rr$ SPARSE_TENSOR)rzrrrrrps r\rz.SparseTensorCreationSkipVariable.call_function s] )$**j#djj/B:  *WX_W`akk5%334 r[ rWrXrYrrr~rr>rrrrrs@r\rMrM \9c9S9T9 # ' S/)*    r[rMcXeZdZdZdededdffd Zddd eedee efdefd Z xZ S) TritonSetAllocatorSkipVariablezm Skip variable for triton.set_allocator with a clear message to move it outside the compiled region. r rr]Nc .d}t||fd|i|y)Nz:triton.set_allocator is not supported inside torch.compilerrOrPs r\r~z'TritonSetAllocatorSkipVariable.__init__ sM 8v88r[rrErc$tddddgy)Nz"triton.set_allocator not supportedz2triton.set_allocator called inside compiled regionz{triton.set_allocator is not supported inside torch.compile. It modifies global Triton allocator state and cannot be traced.zgMove triton.set_allocator() outside of the torch.compile region (call it before the compiled function).rrrs r\rz,TritonSetAllocatorSkipVariable.call_function s" 8HR: r[rSrs@r\rVrV rTr[rVr)rrrrrrrrrrrArcollections.abcrrrrtypingrr r r r r typing_extensionsrweakrefrr_torch._dynamo.excr torch._guardsrtorch.utils._pytreerrrrrrbytecode_transformationrrrrrrrrrr r!r"r#r$r%guardsr&r'rr(r)r*r+r,r-r.r/r0r`r1r2r3r4r5r6r7r8rr:r;r<r=r>rar?r@#torch.distributed.fsdp._fully_shardrAModuleNotFoundErrortorch._dynamo.codegenrBrrCrDrErF#torch._dynamo.variables.ctx_managerrGrrHrIrrJrKrrLrMrvrxrrurr rTrrrV lru_cachercrerrrrrrrrrrrrrrrrrrrr?rArPr0rprr^rrrrrr*r4r:r<rYr_rfrrrrrrrr rrrr0r<r?rErMrVrZr[r\rgs.  ".(GG#% 4 3>>VV    1      ?E / L 6& T#s(+,  &'OP"+YK"8D,=+> sCx (> 0  :  >L\U UU}U 3- U cN U  #  UrDH A A&) A39D= A A.0.$sCx..T. # o% &  ..   * ..CH~ FCK 4'  8_t #  S#X% c3h$& 4--%+-5;d]-JM--622jWY3WYt !73!7H)":)X:4:@G;?G;T   M %=M ` " Fq--q-h> 2><>"6>:c  ? #  o% &   ,G)!9G)T*>(B*>ZM ?M `>"6>s l$8#9 -?-`$)$)N/BD oD N    "J(<"JJ46';46n '; : %9 ebs)PPP