o Zh"@sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZddlmZddlmZddlZddlmZmZdd lmZmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ>zddl?m@Z@Wn eAydZ@Ynwe rddlBmCZCddlDmEZEmFZFede dZGd[d\ddZHd\ddZIdeJeKed?d?e<Z]d@dAZ^d\dBdCZ_GdDdEdEeQZ`GdFdGdGeQZaGdHdIdIeQZbGdJdKdKe<ZcGdLdMdMe<ZdGdNdOdOe<ZeGdPdQdQe<ZfddRlDmgZgmhZhGdSdTdTehZieiZjGdUdVdVe<ZkGdWdXdXe<ZlGdYdZdZe<ZmdS)]a Function-related variable tracking classes for Dynamo's symbolic execution. This module contains classes that track different types of functions during graph compilation, including: - User-defined functions and methods - Built-in functions and methods - Wrapped functions (e.g. from decorators) - Special function types (e.g. functools.partial) - Triton kernels and related function types These classes are responsible for: - Tracking function calls and their arguments - Managing function closures and cell variables - Handling function attributes and special methods - Maintaining guards for function identity and closure contents - Supporting function inlining and specialization - Enabling proper symbolic execution of different function types The variable trackers here work together with the rest of Dynamo to enable accurate graph capture while handling Python's various function-related behaviors. N)Sequence)AnyCallableOptional TYPE_CHECKINGTypeVar)Never)patch) polyfills variables)create_call_function create_rot_n is_generator) get_dynamo_observed_exceptionhandle_observed_exceptionInfiniteGeneratorErrorObservedExceptionObservedGeneratorExitObservedUserStopIterationraise_observed_exception SkipFrame unimplementedunimplemented_v2 Unsupported) GuardBuilder install_guard) AttrSourceConstantSourceDefaultsSource GetItemSource) check_constant_argscheck_unspec_or_constant_argscmp_name_to_op_mappingcountersidentity is_functionis_wrapper_or_member_descriptoristype make_cell)typestrValueMutationNewVariableTrackerConstantVariable)_fsdp_param_group)InstructionTranslator)TritonGridTypeTritonKernelType_F)boundtxr1cCs,t|tr|S|st||Stj||SN) isinstancer-buildr LazyVariableTrackercreate)r6valsourcer>P/var/www/auris/lib/python3.10/site-packages/torch/_dynamo/variables/functions.pywrap_bound_argXs  r@cCs6t|D]\}}t|ttfrt||||<qdSr7)listitemsr8tupledictr@)r6resultkvr>r>r?wrap_args_kwargsds rHrEcCsB|jj}|jD]}|}||vr|||||||<qdS)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_cellvarsZtrack_cell_newZ store_cellpop)parentrEcoderJnameZnew_cellr>r>r? init_cellvarsks  rPc Csdddlm}||||||}||_t|tr"ddlm} t| |}|dus-t|ts-J||_|S)Nr) FunctionTypepairwise) typesrQ__kwdefaults__r8rC itertoolsrSrD__annotations__) rN f_globalsrOdefaultsclosure kwdefaults annotationsrQfuncrSr>r>r?_create_nested_fn|s    r^>__code__ __globals__ __closure____doc__rW __defaults__rUcCsl|ot||}zt||}Wntytt|Ynw|tvr't||}|r0tj ||St ||Sr7) rinspectgetattr_staticAttributeErrorrfn_known_dunder_attrsgetattrr r:r;r-r9)r6fnr=rOZsubobjr>r>r?fn_var_getattrs   rjc@s\eZdZddZddZ     dd dZddded efddZddZ ddZ dS)BaseUserFunctionVariablecC |jSr7get_code co_filenameselfr>r>r? get_filename z%BaseUserFunctionVariable.get_filenamecCrlr7rnco_namerpr>r>r?get_namersz!BaseUserFunctionVariable.get_namer6r1argslist[VariableTracker]kwargsdict[str, VariableTracker]returnr-cCs||g|||Sr7)Zinline_user_function_return self_argsrqr6rwryr>r>r? call_functionsz&BaseUserFunctionVariable.call_functionrOcCsLd}z t||}Wnty|dkrt|trd}Ynwtj|S)NF__name__T)hasattr get_functionNotImplementedErrorr8NestedUserFunctionVariabler r/r;rqr6rOrEr>r>r?call_obj_hasattrs  z)BaseUserFunctionVariable.call_obj_hasattrcCstt|jSr7)rArd signaturer parametersrpr>r>r?inspect_parameter_namesz0BaseUserFunctionVariable.inspect_parameter_namescCiSr7r>rqr6r>r>r? closure_varsz%BaseUserFunctionVariable.closure_varsNr6r1rwrxryrzr{r-) r __module__ __qualname__rrrvr~strr-rrrr>r>r>r?rks*   rkcseZdZdZddhejZeddZd)d*fd d Zfd d Z d dZ ddZ ddZ ddZ ddZddZdeeeffddZdddefddZdddedefd d!Z   " # $ %  &d+fd'd( ZZS),UserFunctionVariablez-Some unsupported user-defined global functionri is_constantcCt|tj|||dSNr=)r make_guardrZ CLOSURE_MATCHclsvaluer=r>r>r?create_with_sources z'UserFunctionVariable.create_with_sourceFr{Nc sptjdi|t|ddrd|_nd|_t|tjtjj fs,Jdt |d|t |d|}||_ dS)NZ_dynamo_marked_constantFTzexpected FunctionType found  Z_torchdynamo_inliner>)super__init__rhrr8rTrQtorchZjitZScriptFunctionr+rdrerirqrirry __class__r>r?rs  zUserFunctionVariable.__init__cst|tr|jStSr7)r(rriras_python_constantrprr>r?rs  z'UserFunctionVariable.as_python_constantcCgSr7r>rpr>r>r?r|rzUserFunctionVariable.self_argscC|jSr7rirpr>r>r?rz!UserFunctionVariable.get_functioncC|jjSr7)rir_rpr>r>r?rnzUserFunctionVariable.get_codecCtjSr7rTrQrpr>r>r? python_typerz UserFunctionVariable.python_typecCst|jddduSN__self__)rhrirpr>r>r?has_selfzUserFunctionVariable.has_selfcCrr7)rir`rpr>r>r? get_globalsrz UserFunctionVariable.get_globalsc sjrJ|jj}tjt|dj}|jpg}fddt|D}t |j |j |j tfddt||D|j}|jrWfdd|jDfdd|jD|_t|j|i|} | t| j} t|| t|| |j jjp~d} t| tjj jksJttjj j| D]e\} } }|jj}||vr||}nOj rt!t"j d | }t"|d }z t#$||j%|}Wn t&yt'(}Ynw|)|||}nz t#$||j%}Wn t&yt'(}Ynw|)d ||}|| | <q| S) z Assume `args` and `kwargs` are VariableTracker arguments for a call to this function, create new bindings for initial locals. )r6cs*g|]\}}jdur dntj|qSr7r=r).0idx_rpr>r? sz2UserFunctionVariable.bind_args..csg|] \}}||dqS)r<r=r>)rargr=)wrapr>r?rs cs,i|]}|jdur dntj|ddqS)NT)Zis_kwr)rrFrpr>r? !s z2UserFunctionVariable.bind_args..cs"i|] \}}|||dqSrr>rrFrG)kwdefaults_sourcesrr>r?r)sr>ra cell_contentsN)*rrIroot_tx functoolspartialr@rirc enumeraterTrQr_r`rrCziprarUrBrdrbindapply_defaultsrD argumentsrHrPlen co_freevarsrVcountrJr=r rr-r9r ValueErrorr ZDeletedVariableZtrack_cell_existing)rqrMrwryrrirYZdefaults_sourcesZ fake_funcr5rErZrrOcellrJZcell_varZ closure_cellZclosure_cell_contentsZ contents_varr>)rrqrr? bind_argss|                zUserFunctionVariable.bind_argsr6r1rOcC&|tvr t||St||j|j|Sr7)r#r GetAttrVariablerjrir=rqr6rOr>r>r? var_getattr\s z UserFunctionVariable.var_getattrcCst|j|}tj|Sr7)rrir r/r;rr>r>r?ras  z%UserFunctionVariable.call_obj_hasattrrwrxryrzr-c sJ|jtjjurEt|jj|i|}|jd}t|t s*| }t d|j dt|t s;|}t d|d|j}tj|ddS|jrSt||j|||S|jjjr|jjjszddlm} Wn typd} Ynw| dur|j| j| jfvrtjj|t|||WdS1swYt|||S) Nrz=`nonstrict_trace` expects a callable, but got value of type <>z) Applying `nonstrict_trace` to function ; however, `nonstrict_trace` currently requires the function to be defined outside `torch.compile` region. TZnonstrict_traceable) FSDPState)rir_dynamoZnonstrict_tracerdrrrwr8rkrrrrrvr TorchInGraphFunctionVariablerinvoke_and_store_as_constantrIZcurrent_tracerZunder_activation_checkpointZ#allow_side_effects_under_checkpointZ/torch.distributed.fsdp._fully_shard._fsdp_stater ExceptionZ _pre_forwardZ _post_forwardrJrr~) rqr6rwryr5Zfn_vartypfn_namerirrr>r?r~gsL       z"UserFunctionVariable.call_functionFr{Nr)rrrrbrk_nonvar_fields classmethodrrrr|rrnrrrrDrr-rrrr~ __classcell__r>r>rr?rsF  W rcsFeZdZddfdd ZeddZ   dddZZS)BuiltinMethodVariableFr{Nc s,tjdi|t|tjsJ||_dSNr>)rrr8rTBuiltinMethodTyperirrr>r?rs zBuiltinMethodVariable.__init__cCs0|j}|j}|tur|dkpt|tuo|dkS)N__new__ __contains__)rrrCtype frozenset)obj method_self method_namer>r>r?is_supported_builtin_methods z1BuiltinMethodVariable.is_supported_builtin_methodr6r1rwrxryrzr-cCs@|jj}|jj}|jot|jd}t|||}|||||Sr)rirrr=rr-r9 call_method)rqr6rwryrrOZ obj_sourceZobj_vtr>r>r?r~s z#BuiltinMethodVariable.call_functionrrr)rrrr staticmethodrr~rr>r>rr?rs  rc seZdZdejdedffdd ZddZdd Zd d Z d d Z ddZ ddZddZ e Z ddZddZddZddZddZddZd d!Zd"ejfd#d$Zd"eefd%d&Zd'd(Zd)d*Zd+d,Zd-dd.ed/d0d1d2d"d3f fd4d5 ZZ S)6LocalGeneratorObjectVariablerN inline_tracerr1c s(tjdi|||_||_||_dSr)rrrNrXr)rqrNrXrryrr>r?rs z%LocalGeneratorObjectVariable.__init__cCrr7)rNrpr>r>r?rnrz%LocalGeneratorObjectVariable.get_codecCrlr7rmrpr>r>r?rrrsz)LocalGeneratorObjectVariable.get_filenamecCrlr7rtrpr>r>r?rvrsz%LocalGeneratorObjectVariable.get_namecCstr7)rrpr>r>r?rrz)LocalGeneratorObjectVariable.get_functioncCdSNFr>rpr>r>r?rrz%LocalGeneratorObjectVariable.has_selfcC|Sr7)rvrpr>r>r?rrz%LocalGeneratorObjectVariable.__name__cCs|jjd|dS)N())rrrvrpr>r>r?__str__sz$LocalGeneratorObjectVariable.__str__c Csddlm}ddlm}m}m}|}||}||}||} |L|1| ||} | js7| ||_ t |j  |Wdn1sJwYWdn1sYwYWddSWddS1sqwYdS)Nr)"disallow_side_effects_in_generator)r1 save_and_restart_speculation_log(temporarely_allow_writes_to_output_graph)Ztorch._dynamo.side_effectsrtorch._dynamo.symbolic_convertr1rrZ current_tx_get_inline_tracergenerator_exhaustedforce_unpack_var_sequenceZremaining_itemsr ZListIteratorVariable reconstruct) rqcodegenrr1rrr6saveZdisallowtemptracerr>r>r?rs   Pz(LocalGeneratorObjectVariable.reconstructcCs|j|||Sr7)rirr}r>r>r?rz&LocalGeneratorObjectVariable.bind_argscCrr7rXrpr>r>r?rrz(LocalGeneratorObjectVariable.get_globalscCrr7)rT GeneratorTyperpr>r>r?rrz(LocalGeneratorObjectVariable.python_typecCs.ddlm}|jdur|||gi|_|jSNr)InliningInstructionTranslator)rrrbuild_inline_tracer)rqr6rr>r>r?rs  z/LocalGeneratorObjectVariable._get_inline_tracerc Cs||}|rtt|zfz,ttdtdi|WdWWtdtdO<S1s5wYWn,tyI}z|d}~wt yPt yg}z t j j |t|d}~wwWtdtdO<dStdtdO<w)NrZ inline_call)r_is_generator_exhaustedr StopIterationr rDr$Z inline_call_rrrrrZ eval_frameZ skip_codernr)rqr6rer>r>r? next_variables*    . z*LocalGeneratorObjectVariable.next_variablecCrrr>rr>r>r?has_unpack_var_sequencerz4LocalGeneratorObjectVariable.has_unpack_var_sequencer{cCrNTr>rr>r>r?has_force_unpack_var_sequencerz:LocalGeneratorObjectVariable.has_force_unpack_var_sequencecCs:g} z |||Wntyt|Y|Swqr7)appendrrr)rqr6rEr>r>r?rs z6LocalGeneratorObjectVariable.force_unpack_var_sequencec CsL||}z||WdSty%}z ||WYd}~dSd}~wwr7)rZ_raise_exception_variablerZexception_handler)rqr6excrrr>r>r?_setup_exception%s z-LocalGeneratorObjectVariable._setup_exceptioncCs|jdup |jjdkS)Nr)rZinstruction_pointerrpr>r>r?_is_generator_just_started.sz7LocalGeneratorObjectVariable._is_generator_just_startedcCt|jddS)NrF)rhrrpr>r>r?r1sz4LocalGeneratorObjectVariable._is_generator_exhaustedr6rOrwrxryrzr-c s.|dkr ||S|dkr|S|dkr8|r)t|r)tdd|Ds)tt|||}||||S|dkr||}|sI|rQd|_ t dSz | |t tdtjd krp|jjd krpd|_ t dWSWntyd|_ t dYSwz ||rtt|Wn|tyd|_ t dYSty|jdusJ|jYSw|d kr ||}z| |t|d kr|d n|dWntyw||}tdtfi}z| |t |d||Wn t|yY|Swtt||St||||dS)N__next____iter__sendcss$|] }t|to |jduVqdSr7)r8r/rrrr>r>r? Gs  z;LocalGeneratorObjectVariable.call_method..closeTr>) ZCALL_INTRINSIC_1throwrr*rZ__InternalThrowException)rrrallr TypeErrorrZ push_manyrrr r/rZExceptionVariable GeneratorExitsys version_infoZnext_instructionopnamer RuntimeErrorrZsymbolic_resultrrrrrr)rqr6rOrwryrretvalexc_typerr>r?r4sz                   (  > z(LocalGeneratorObjectVariable.call_method)!rrrrTCodeTyperrrnrrrvrrr__repr__rrrrrrr builtinsboolr rAr-rrrrrrrr>r>rr?rsJ    rc@seZdZdZdS)4ContextlibContextManagerLocalGeneratorObjectVariablez .. note:: This is only used when the function is annotated with @contextlib.contextmanager It is a special case of a generator function as we do not allow return a context manager from a torch.compile function. N)rrrrbr>r>r>r?r'sr'csVeZdZdZeddeffddZddZdd Z    dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_clsvtc "tjdi|||_||_dSr)rrr*r))rqr*r)ryrr>r?rs z'LocalGeneratorFunctionVariable.__init__cCs&||jjvr t||St|j|Sr7)r__dict__keysrhr*)rqrOr>r>r? __getattr__s  z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr)rrr)rqr6rwryrr>r>r?_build_inline_tracers z3LocalGeneratorFunctionVariable._build_inline_tracerr6r1rwrxryrzr{r-cCsHt|js J||||}|j}|j}|j||||jdSr)rr*rnr/rr)r=)rqr6rwryrrNrXr>r>r?r~ s  z,LocalGeneratorFunctionVariable.call_functionr) rrrrbrr-rr.r/r~rr>r>rr?r(s"   r(cs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)Nr))rrr')rqr*ryrr>r?r>s zr?r/EszHFunctionDecoratedByContextlibContextManagerVariable._build_inline_tracer)rrrrbrr/rr>r>rr?r05s r0cseZdZdZdfdd ZdefddZdd Zd d Z      dfdd Z fddZ d d deffdd Z Z S)UserMethodVariablez$Some unsupported user-defined methodr{Nc s tjdd|i|||_dS)Nrir>)rrr)rqrirryrr>r?rVs zUserMethodVariable.__init__cCs|jjd|jd|jdS)Nrz, r)rrrirrpr>r>r?r$ZszUserMethodVariable.__repr__cCs|jgSr7)rrpr>r>r?r|]rzUserMethodVariable.self_argscCrr7)rT MethodTyperpr>r>r?r`rzUserMethodVariable.python_typer6r1rwrxryrzr-c sddlm}||jr"g||}tj|jdd}||||S|jrTt |j tj rTt |jdd}|durB| drB|dksE|jrS|j j||jj|||jd Sntduro|jtjjurot|j||j g|R|S|jrt |j j|jj}t|||||St|||S) Nr )is_nonstrict_trace_callableTrrz torch.nn.ztorch.nn.utils.parametrize)constant)Z trace_rulesr3rir|r rr~rIZis_root_tracerr8rZNNModuleVariablerh startswithrrrr0ZFSDPParamGroupZuse_training_stateZTorchCtxManagerClassVariablerrrvr) rqr6rwryr3Z call_argsvarZ module_attrrirr>r?r~cs<    z UserMethodVariable.call_functioncstddSNr*)rrrprr>r?rrz*UserMethodVariable.inspect_parameter_namesrOcsF|jot|j|}|dkr|jS|dkrt||j|St||S)Nr__func__)r=rrr-r9rirr)rqr6rOr=rr>r?rs zUserMethodVariable.var_getattrrr) rrrrbrrr$r|rr~rrrr>r>rr?r1Ss" =r1c<eZdZdfdd Z      dfd d ZZS)WrappedUserMethodVariabler{Nc sB|dd|ddtj|j|jfi|||_||_dSNrir)rLrrrirwrappedcontextrqr=r>ryrr>r?rs   z"WrappedUserMethodVariable.__init__r6r1rwrxryrzr-c,|j|t|||}|j||Sr7r>Zenterrr~exitrqr6rwryrErr>r?r~  z'WrappedUserMethodVariable.call_functionrrrrrrr~rr>r>rr?r;r;cr:)WrappedUserFunctionVariabler{Nc s>|dd|ddtj|jfi|||_||_dSr<)rLrrrir=r>r?rr>r?rs   z$WrappedUserFunctionVariable.__init__r6r1rwrxryrzr-cr@r7rArCrr>r?r~rDz)WrappedUserFunctionVariable.call_functionrrrEr>r>rr?rGrFrGcsTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr |S|Sr7)r8r TensorVariableZget_real_valuer)xr>r>r?converts z-invoke_and_store_as_constant..convertcsg|]}|qSr>r>rrIrJr>r?rz0invoke_and_store_as_constant..csi|] \}}||qSr>r>rrLr>r?rz0invoke_and_store_as_constant..r)rBrIZregister_attr_or_moduler)r6rirOrwryresr>rLr?rsrcsxeZdZdhejZ d dfdd ZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZZS)rrXNr{c  sztjdi| t|tsJt|tjsJt|ts#J||_||_ ||_ ||_ ||_ ||_ ||_||_dSr)rrr8rrrTr#rDrrNrXrYr[r\rZ wrapped_fn) rqrrNrXrYr[r\rZrPryrr>r?rs z#NestedUserFunctionVariable.__init__cCrr7r>rpr>r>r?r|rz$NestedUserFunctionVariable.self_argscCs |jSr7)rNrrpr>r>r?rnrsz#NestedUserFunctionVariable.get_codecCrr7rrpr>r>r?r rz&NestedUserFunctionVariable.python_typecCs|jrtt|j|j|j}|jr|j|_ |j r%|j |_ |j rH|j }t |tr>ddlm}t||}t |tsEJ||_|S)NrrR)rZrrTrQrNrrXrrYrcr[rUr\r8rCrVrSrDrW)rqr]r\rSr>r>r?rs&      z'NestedUserFunctionVariable.get_functioncCs |jduSr7)rZrpr>r>r? has_closure&rsz&NestedUserFunctionVariable.has_closurecCrrr>rpr>r>r?r)rz#NestedUserFunctionVariable.has_selfcCrr7rrpr>r>r?r,rz&NestedUserFunctionVariable.get_globalsc Cs|}t||j|j|jrt|jjndtddt t |j D}|j r1|j |_t|j|i|}|t|j}t|jj|t|||t|j D]\}} | |vscJ|jj|} | || <qY|S)Ncss|]}tdVqdSr7)r))rrr>r>r?r6z7NestedUserFunctionVariable.bind_args..)rnrTrQrXrrrYrCrBrangerrr[Zkeys_as_python_constantrUrdrrrrDrrHrIrrPrrZ) rqrMrwryrNr]r5rErrOrr>r>r?r/s(     z$NestedUserFunctionVariable.bind_argscsnfdd|j|jgt|jjj|j r+|j n  dg|j r=|j n  dg|j rO|j n  dg|j rzz|j }|gWntyy|j Yn w dgtdd|jrfdd|jtddtdtdddSdS) Ncs tdS)Nr^)load_import_fromrr>rr>r?I z8NestedUserFunctionVariable.reconstruct..Fc ddS)NrwrapsrTr>rUr>r?rVmrWr*r T) add_push_nullrN extend_outputZcreate_load_const_uncheckedrXr/r;rrurYZcreate_load_constrZr[r\rrr rPr)rqrr\r>rUr?rGsF          z&NestedUserFunctionVariable.reconstructr7r)rrrrkrrr|rnrrrQrrrrrr>r>rr?rs$ rcsxeZdZddhejZddfdd ZddZed d Z     dddZ dddZ d d de fddZ Z S)SkipFunctionVariablerreasonNr{c r+r)rrrr_)rqrr_ryrr>r?r| zSkipFunctionVariable.__init__cCrr7rrpr>r>r?rrz'SkipFunctionVariable.as_python_constantcCs$t|s t|tj|||dSr)r'rrrFUNCTION_MATCHrr>r>r?rs z'SkipFunctionVariable.create_with_sourcer6r1rwrxryrzr-c Cs@t|jddrtdt|jd|jddgddS|jtjjurC|dd}|r.| }td d |d |d d |dgddSt |jt j r^d|jd}tjj |t|dSt|jdd}z)t|j}d|d|d}d|dg} d|vr| d|d|ddg7} Wnjtyddh} |jj| vrd|jjd |d}d!d"g} nG|jjdur|jjd#rd$|jjd |d }d%g} tjj |d&d&| nd'|jjd |d(}d)d*g} tjj |d&d&| Ynw|d+krd,}g} |jr |jnd-} td.d/|jjd0|d1| || ddS)2NZ_torchdynamo_disableFz1Skip calling `torch.compiler.disable()`d functionzSkip calling function `z4` since it was wrapped with `torch.compiler.disable`z(Remove the `torch.compiler.disable` call)Zgb_typer> explanationhintsmsgz%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.z2Graph break due to unsupported wrapper descriptor zM. Please file an issue on GitHub so the PyTorch team can add support for it. rzz?Dynamo developers have intentionally marked that the function `z ` in file `z` should not be traced.zAvoid calling the function `z`.rzRemove the function `z` or the file `zv` from torch/_dynamo/trace_rules.py. 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. Zoptreez*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`.Zallow_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: )rdrerrrrrZ graph_breakgetrr8rTWrapperDescriptorTypeutilsZ warn_oncerrhgetfilerrr6joinr_) rqr6rwryZgraph_break_msgrequalnamepathrcrdZknown_python_builtin_modulesr_r>r>r?r~s              ) z"SkipFunctionVariable.call_functioncCstjt|j|Sr7)r r/r;rrrr>r>r?rrz%SkipFunctionVariable.call_obj_hasattrrOcCrr7)r#r rrjrr=rr>r>r?rs z SkipFunctionVariable.var_getattrr7rrr6r1)rrrr-rrrrrr~rrrrr>r>rr?r^us*  qr^csJeZdZdZdfdd Zdfdd Z    dddZZS)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". r{Nc r+r)rr wrapper_obj attr_to_trace)rqrtruryrr>r?rr`z$WrapperUserFunctionVariable.__init__r6r1csF||jkrt|j|j}|jot|j|}t|||St||Sr7) rurhrtr=rr-r9rr)rqr6rOr<r=rr>r?rs z'WrapperUserFunctionVariable.var_getattrrwrxryrzr-cCs&ttj||t|jg||Sr7)r rr Zgetattr_and_tracer~r/rur}r>r>r?r~sz)WrapperUserFunctionVariable.call_functionrrrr)rrrrbrrr~rr>r>rr?rssrscCstjr ddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesrwrvr>r>r?_traceable_collective_remaps*s  r{cCs>tjs Jd|tvsJ|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rrxryr{valuesrZ import_sourcer)r6riZ inner_nameZ path_sourcer>r>r?_traceable_collectives_source5s   r}csdeZdZdZdfdd Zeddd Zed d Zedd d Z        dddZ Z S)!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{Nc s,tj|fi|t|tsJ||_dSr7)rrr8rreplacement_var)rqrirryrr>r?rIs z*CollectiveFunctionRewriteVariable.__init__r6r1cKs6t||\}}t|ft|fd|i||d|S)Nr=)rr=)r~rewriter)r6Zold_fnr=optionsnew_fnZ new_sourcer>r>r?r;Nsz(CollectiveFunctionRewriteVariable.createcCst|o |tvSr7)rd isfunctionr{)variabler>r>r? can_rewriteXsz-CollectiveFunctionRewriteVariable.can_rewritecCst|}|t||fSr7)r{r})r6rirr>r>r?r^s z)CollectiveFunctionRewriteVariable.rewriterwrxryrzr-c Csddlm}ddlm}t|j}t|j|i|j }d}d|vr1|d r1t d|j|j|j |j |jfvrc|d}|durH|jn|jdj}||vrYtd|tj|||d<|j|||S)Nr)REDUCE_OP_TO_STRr>Zasync_opzBCollectiveFunctionRewriteVariable can't support async_op=True for opzUnsupported all_reduce op: )Ztorch.distributedrxrzrrdrrirDrrrrZ all_reduceZreduce_scatter_tensorZ_reduce_scatter_baserkrrdefaultrr r/r;rr~) rqr6rwrydistrrZ reduce_op_varZ reduce_opr>r>r?r~cs2     z/CollectiveFunctionRewriteVariable.call_functionrrrr) rrrrbrrr;rrr~rr>r>rr?r~>s$    r~cs.eZdZ        d fd d ZZS) FunctoolsWrapsVariabler6r1rwrxryrzr{r-cs6|stdkrfdd}t|St||S)Nr*cs0t|tjr|jddStd|ddS)Nr)rPzfunctools.wraps(r)r8r rclonerrrwr>r?rZs z3FunctoolsWrapsVariable.call_function..wraps)rr ZLambdaVariablerr~)rqr6rwryrZrrr?r~s  z$FunctoolsWrapsVariable.call_functionr)rrrr~rr>r>rr?rsrc@s.eZdZddZ       dd d Zd S)CollectionsNamedTupleFunctioncCrr7rrpr>r>r?rrz0CollectionsNamedTupleFunction.as_python_constantr6r1rwrxryrzr{r-cCsRt||}|r#|jdd|Didd|D}tj|tdStddS)NcSg|]}|qSr>rrKr>r>r?rrMz?CollectionsNamedTupleFunction.call_function..cSi|] \}}||qSr>rrr>r>r?rrNz?CollectionsNamedTupleFunction.call_function..)Z mutation_typez!namedtuple with non constant args)r!rirBr ZUserDefinedClassVariabler,r)rqr6rwry constant_argsrr>r>r?r~s   z+CollectionsNamedTupleFunction.call_functionNr)rrrrr~r>r>r>r?rsrcseZdZdeddffdd ZddZdd Zd d Z      dddZd d de defddZ d d de fddZ ddZ ddZ ZS)FunctoolsPartialVariabler]r{Nc sPtjdi|||_t|tsJ||_t|tsJ||_t t |_ dSr) rrr]r8rArwrDkeywordsrrr%Z fake_value)rqr]rwrryrr>r?rsz!FunctoolsPartialVariable.__init__cCrr7)rrrpr>r>r?rrz$FunctoolsPartialVariable.python_typecsfdd|j|jr|j|js)tt|jdddS|jt |j } t|t|jd|ddS)NcrY)Nrrr[r>rUr>r?rVrWz6FunctoolsPartialVariable.reconstruct..r*F) r\r]rwforeachrr]r rr|rCr-Zcreate_call_function_kw)rqrr-r>rUr?rs  z$FunctoolsPartialVariable.reconstructcCrr7rrpr>r>r?rrz%FunctoolsPartialVariable.get_functionr6r1rwrxryrzr-cCs(|j|}i|j|}|j|||Sr7)rwrr]r~)rqr6rwryZ merged_argsZ merged_kwargsr>r>r?r~s z&FunctoolsPartialVariable.call_functionrOcCstjttt|Sr7)r r/r;rrrr%rr>r>r?rsz)FunctoolsPartialVariable.call_obj_hasattrcCsp|jot|j|}|dkr|jS|dkrtj|j|dS|dkr1dd|jD}tj||dSt t |dS)Nr]rwrrcSsi|] \}}t||qSr>)r/r;rr>r>r?rsz8FunctoolsPartialVariable.var_getattr..) r=rr]r ListVariablerwrrBConstDictVariablerrf)rqr6rOr=rBr>r>r?rsz$FunctoolsPartialVariable.var_getattrcC:tj|jgdd|jDRidd|jDS)NcSrr>rrr>r>r?rrMz?FunctoolsPartialVariable.as_python_constant..cSrr>rrr>r>r?rrNz?FunctoolsPartialVariable.as_python_constant..)rrr]rrwrrBrpr>r>r?rsz+FunctoolsPartialVariable.as_python_constantcCr)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantscSrr>guard_as_python_constant)rrGr>r>r?rrMzEFunctoolsPartialVariable.guard_as_python_constant..cSrr>rrr>r>r?rrNzEFunctoolsPartialVariable.guard_as_python_constant..)rrr]rrwrrBrpr>r>r?rsz1FunctoolsPartialVariable.guard_as_python_constantr)rrrr-rrrrr~rrrrrrr>r>rr?rs0     rcseZdZdddhejZeeddee de fe j ffddZ ed d Zdeddffd d Zedefd dZddZddZ        d ddZ      d!ddZddZZS)"PolyfilledFunctionVariablerirP traceable_fnNr{.cCrr7r>)rr>r>r?_get_polyfill_handlers sz1PolyfilledFunctionVariable._get_polyfill_handlerscCrr)rrrrbrr>r>r?rs z-PolyfilledFunctionVariable.create_with_sourcec stjdi|||_|||}t|s"Jd|d|dD]}t||d}|r8t|s4J|}n q$td|d||_||_ dS)NzPolyfill handler z is not callable for )Z__torch_dynamo_polyfill__Z__python_implementation__z# does not have a traceable functionr>) rrrirrkcallablerhr rPr)rqriryhandlerZcandidate_attr candidaterrr>r?rs     z#PolyfilledFunctionVariable.__init__cCrr7)rrpr>r>r? polyfill_fn/sz&PolyfilledFunctionVariable.polyfill_fncCr)NZ*__torch_dynamo_can_constant_fold_through__F)rhrPrpr>r>r?can_constant_fold_through3z4PolyfilledFunctionVariable.can_constant_fold_throughcCrr7rrpr>r>r?r8rz'PolyfilledFunctionVariable.get_functionr6r1rwrxryrzr-c Cs|r#t||r#|jdd|Didd|D}t||S|jtjurot|dkro|sot |dt j t j frot dd|djDrot jj||jd tjtd d|djDfitd d|djDd St||j}||||S) NcSrr>rrKr>r>r?rFrMz.cSrr>rrr>r>r?rGrNz.r*rcss@|]}t|tjrt|jtpt|tjo|tuVqdSr7)r8r r/rintSymNodeVariablerrKr>r>r?rRs  z;PolyfilledFunctionVariable.call_function..r~css|]}|VqdSr7as_proxy)rar>r>r?r]rRcSs$g|]}t|tjr |jn|jqSr>)r8r r/rsym_numrKr>r>r?ras  )r)rr"rirBr-r9r%sumrr8r r TupleVariablerrr;rI create_proxyrZsym_sumrCrr~)rqr6rwryrEZtraceable_function_variabler>r>r?r~;sH      z(PolyfilledFunctionVariable.call_functioncCs|dkr ||||St|j|d}|dus!Jd|d|jt|s0Jd|d|ji}|jr=t|j||d<t|fi|}||||S)N__call__zMember z not found in z is not callable in r=)r~rhrir&r=rr)rqr6rOrwrymethodrZpolyfilled_method_variabler>r>r?rosz&PolyfilledFunctionVariable.call_methodcCrr7rrpr>r>r?rrz-PolyfilledFunctionVariable.as_python_constantrrwrxryrzr{r-)rrrr-rrr lru_cacherDrrrTrQrrr4rpropertyrrrr~rrrr>r>rr?rsD$  4 rc@seZdZddZdS)TracebackVariablecCsdSr7r>r}r>r>r?r~szTracebackVariable.call_functionN)rrrr~r>r>r>r?rs rcs4eZdZfddZddZddZddZZS) SysFunctionVariablec stjdi|||_dSr)rrr)rqrryrr>r?rs zSysFunctionVariable.__init__cCs`t|jr|jd}|j}d}t|||t||g}ntdtdtdg}t|S)N)rZ exn_vt_stackr"r-r9r r/r)rqr6ZexnrtbrBr>r>r?exc_infos     zSysFunctionVariable.exc_infocCs||jdSr8)rrBrr>r>r? exceptionrzSysFunctionVariable.exceptioncCsB|jtjur ||S|jtjur||Std|jjdS)Nzsys.)rrrrrrr}r>r>r?r~s    z!SysFunctionVariable.call_function)rrrrrrr~rr>r>rr?rs  r)TMADescriptorMetadataTritonHOPifierc@seZdZdedefddZdedefddZdedefd d Z de e j j jd ffd d ZddZddZddZddZdedefddZdddeeddfddZdefddZd S)!DynamoTritonHOPifierrer{cCst|r7)r)rqrer>r>r?raise_unsupportedrz&DynamoTritonHOPifier.raise_unsupportedmaybe_callablecCst|ttfSr7)r8rr)rqrr>r>r? is_callablerz DynamoTritonHOPifier.is_callabler<cCs|jSr7ra)rqr<r>r>r? get_valuerzDynamoTritonHOPifier.get_value.cCs4ddlm}t||r|Stdt|dS)Nr*)BaseListVariablezgrid for the triton kernel is )listsrr8rrr)rqgridrr>r>r? check_grids  zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSi|] \}}tj||qSr>r r/r;rr>r>r?rsz2DynamoTritonHOPifier.call_grid..)rBr~)rqrmetar6r>r>r? call_gridszDynamoTritonHOPifier.call_gridc Cs*ddlm}|||}||||}|S)Nr*)SourcelessBuilder)builderrr;r~) rqZuser_fnrwryr6rrZwrapped_user_functionrEr>r>r?call_user_defined_fns  z)DynamoTritonHOPifier.call_user_defined_fncCs*ddlm}||t|j||}|S)Nr*)VariableBuilder)rrr kernel_source_wrap)rqZuser_objr6rrOrZwrapped_user_objr>r>r?wrap_user_defined_objs z*DynamoTritonHOPifier.wrap_user_defined_objcCs||}dd|D}|S)NcSrr>r)rconfigr>r>r?rrMz=DynamoTritonHOPifier.maybe_unpack_configs..)Zunpack_var_sequence)rqZconfigsr6r>r>r?maybe_unpack_configss z)DynamoTritonHOPifier.maybe_unpack_configsrEcCs|s |d|S)Nz`@triton.heuristics must return constant values because configs can only contain constant values.)Zis_python_constantrr)rqrEr>r>r?maybe_unpack_heuristic_results z2DynamoTritonHOPifier.maybe_unpack_heuristic_resultrTritonKernelVariablerwcCs>|jdus t|dkr|dt||j|j|d|jdS)Nr*z7Triton kernels should be called with only a single gridr)kernel kernel_idxrr)rrrrrrr=)rqrrwr>r>r? call_getitemsz!DynamoTritonHOPifier.call_getitemc s&ddlmddlm}i}t|D]}||}t|tr+|||<|j j ||<qdd| D} ddl m } m} fdd| D} fd d| D} | D]}|}t|tjtjfsq|d t|d qW| | }|| t}|jd | d |j||||dtdS)Nr*r.)rcSrr>rrr>r>r?rs z1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSr>)r8rrr.r>r?rs cs i|] \}}t|s||qSr>)r8rr.r>r?r$s z.Unexpected argument type for a Triton kernel: rir~r>)rconstant_args_idxrtma_descriptor_metadatary)r5r/ZdictsrrAr-r8TMADescriptorVariable to_metadatadata_ptrZ from_tensorrB*torch._higher_order_ops.triton_kernel_wraprrr|Zrealizer rHrrreprZadd_constant_argsrDrIrrr)rqrZgridsZcombined_args_rawr6rrrFrGZ combined_argsrrrZnon_constant_argsrrr>r.r?call_HOPsT           zDynamoTritonHOPifier.call_HOPN)rrrrrrrr&rrrCrZfxproxyZProxyrrrrrrrrr/rr>r>r>r?rs$   rcseZdZUded<ded<eeed<ded<dfd d Z      dddZ      dfdd Zde de fddZ Z S)rr2rr3rrrrr{Nc s4|dd|_tjdi|t||||dS)Nrr>)rLrrr dynamo_triton_hopifier_singletonZ init_variable)rqrrrryrr>r?rNszTritonKernelVariable.__init__r6r1rwrxryrzr-cCst||||Sr7)rZcall_triton_kernelr}r>r>r?r~Ssz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)rrZcall_runrr)rqr6rOrwryrr>r?r]s  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nr*r.)r)r5r/Ztensorrr8r;Z evaluate_expr)rqrr/rr>r>r?specialize_symbolicls   z(TritonKernelVariable.specialize_symbolicrrr) rrrrWrrrr~rrrrr>r>rr?rHs.    rcs>eZdZ        dfdd Zd d Zd d ZZS)rrvariables.DataPtrVariabledimslist[ConstantVariable] block_dims element_sizer/c s>t|tjsJtjdi|||_||_||_||_dSr) r8r DataPtrVariablerrrrrr)rqrrrrryrr>r?rws  zTMADescriptorVariable.__init__cCs(dd|jDdd|jD|jfS)NcSrr>rrdimr>r>r?rrMz5TMADescriptorVariable.to_metadata..cSrr>rrr>r>r?rrM)rrrrrpr>r>r?rsz!TMADescriptorVariable.to_metadatacsXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorZcreate_Zd_tma_descriptor)rTrrr>rrqr>r?rVsz3TMADescriptorVariable.reconstruct..r*F) r\rrrrrrr~r)rqrrwr>rr?rs   z!TMADescriptorVariable.reconstruct)rrrrrrrr/)rrrrrrrr>r>rr?rvsrcs@eZdZdeddffdd Z     dd dZZS)CreateTMADescriptorVariablerankr{Nc s(|dvsJtjdi|||_dS)N)r*r r>)rrr)rqrryrr>r?rs  z$CreateTMADescriptorVariable.__init__r6r1rwrxryrzr-cCs.d|vr|dn|d}t|tjstd|jd|jdkrGt|t|dks,Jd|vr4|dn|dg}d|vrA|dn|d g}nr>r?r~s6  z)CreateTMADescriptorVariable.call_functionr)rrrrrr~rr>r>rr?rs rr7rr)nrbr%rrdrVrrTcollections.abcrtypingrrrrrZtyping_extensionsrZ unittest.mockr rr4r r Zbytecode_transformationr rrr rrrrrrrrrrrZguardsrrr=rrrr rmr!r"r#r$r%r&r'r(r)baser+r,r-r5r/Z#torch.distributed.fsdp._fully_shardr0ModuleNotFoundErrorrr1rr2r3r4r@rHrDrrPr^rgrjrkrrrr'r(r0r1r;rGrrr^rsr{r}r~rrrrrrrrrrrrrr>r>r>r?s   4 ,       "J > 7Y "  OO#.$