o I h"@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>U/var/www/vscode/kcb/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_cellvarstrack_cell_new store_cellpop)parentrEcoderJnamenew_cellr>r>r? init_cellvarsks  rSc Csdddlm}||||||}||_t|tr"ddlm} t| |}|dus-t|ts-J||_|S)Nr) FunctionTypepairwise) typesrT__kwdefaults__r8rC itertoolsrVrD__annotations__) rP f_globalsrQdefaultsclosure kwdefaults annotationsrTfuncrVr>r>r?_create_nested_fn|s    ra>__doc____code__ __closure__ __globals__ __defaults__rXrZcCsl|ot||}zt||}Wntytt|Ynw|tvr't||}|r0tj ||St ||Sr7) rinspectgetattr_staticAttributeErrorrfn_known_dunder_attrsgetattrr r:r;r-r9)r6fnr=rQsubobjr>r>r?fn_var_getattrs   rnc@s\eZdZddZddZ     dd dZddded efddZddZ ddZ dS)BaseUserFunctionVariablecC |jSr7get_code co_filenameselfr>r>r? get_filename z%BaseUserFunctionVariable.get_filenamecCrpr7rrco_namertr>r>r?get_namerwz!BaseUserFunctionVariable.get_namer6r1argslist[VariableTracker]kwargsdict[str, VariableTracker]returnr-cCs||g|||Sr7)inline_user_function_return self_argsrur6r{r}r>r>r? call_functionsz&BaseUserFunctionVariable.call_functionrQcCsLd}z t||}Wnty|dkrt|trd}Ynwtj|S)NF__name__T)hasattr get_functionNotImplementedErrorr8NestedUserFunctionVariabler r/r;rur6rQrEr>r>r?call_obj_hasattrs  z)BaseUserFunctionVariable.call_obj_hasattrcCstt|jSr7)rArg signaturer parametersrtr>r>r?inspect_parameter_namesz0BaseUserFunctionVariable.inspect_parameter_namescCiSr7r>rur6r>r>r? closure_varsz%BaseUserFunctionVariable.closure_varsNr6r1r{r|r}r~rr-) r __module__ __qualname__rvrzrstrr-rrrr>r>r>r?ros*   rocseZdZdZddhejZeddZd)d*fd d Zfd d Z d dZ ddZ ddZ ddZ ddZddZdeeeffddZdddefddZdddedefd d!Z   " # $ %  &d+fd'd( ZZS),UserFunctionVariablez-Some unsupported user-defined global functionrl is_constantcCt|tj|||dSNr=)r make_guardr CLOSURE_MATCHclsvaluer=r>r>r?create_with_sources z'UserFunctionVariable.create_with_sourceFrNc sptjdi|t|ddrd|_nd|_t|tjtjj fs,Jdt |d|t |d|}||_ dS)N_dynamo_marked_constantFTzexpected FunctionType found  _torchdynamo_inliner>)super__init__rkrr8rWrTtorchjitScriptFunctionr+rgrhrlrurlrr} __class__r>r?rs  zUserFunctionVariable.__init__cst|tr|jStSr7)r(rrlras_python_constantrtrr>r?rs  z'UserFunctionVariable.as_python_constantcCgSr7r>rtr>r>r?rrzUserFunctionVariable.self_argscC|jSr7rlrtr>r>r?rz!UserFunctionVariable.get_functioncC|jjSr7)rlrcrtr>r>r?rrzUserFunctionVariable.get_codecCtjSr7rWrTrtr>r>r? python_typerz UserFunctionVariable.python_typecCst|jddduSN__self__)rkrlrtr>r>r?has_selfzUserFunctionVariable.has_selfcCrr7)rlrertr>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_rtr>r? sz2UserFunctionVariable.bind_args..csg|] \}}||dqS)r<r=r>)rargr=)wrapr>r?rs cs,i|]}|jdur dntj|ddqS)NT)is_kwr)rrFrtr>r? !s z2UserFunctionVariable.bind_args..cs"i|] \}}|||dqSrr>rrFrG)kwdefaults_sourcesrr>r?r)sr>rd cell_contentsN)*rrIroot_tx functoolspartialr@rlrf enumeraterWrTrcrerrCziprdrXrBrgrbindapply_defaultsrD argumentsrHrSlen co_freevarsrYcountrJr=r rr-r9r ValueErrorr DeletedVariabletrack_cell_existing)rurOr{r}rrlr\defaults_sources fake_funcr5rEr]rrQcellrJcell_var closure_cellclosure_cell_contents contents_varr>)rrurr? bind_argss|                zUserFunctionVariable.bind_argsr6r1rQcC&|tvr t||St||j|j|Sr7)r#r GetAttrVariablernrlr=rur6rQr>r>r? var_getattr\s z UserFunctionVariable.var_getattrcCst|j|}tj|Sr7)rrlr r/r;rr>r>r?ras  z%UserFunctionVariable.call_obj_hasattrr{r|r}r~r-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. Tnonstrict_traceable) FSDPState)rlr_dynamononstrict_tracergrrr{r8rorrrrrzr TorchInGraphFunctionVariablerinvoke_and_store_as_constantrIcurrent_tracerunder_activation_checkpoint#allow_side_effects_under_checkpoint/torch.distributed.fsdp._fully_shard._fsdp_stater Exception _pre_forward _post_forwardrJrr) rur6r{r}r5fn_vartypfn_namerlrrr>r?rgsL       z"UserFunctionVariable.call_functionFrNr)rrrrbro_nonvar_fields classmethodrrrrrrrrrrrDrr-rrrr __classcell__r>r>rr?rsF  W rcsFeZdZddfdd ZeddZ   dddZZS)BuiltinMethodVariableFrNc s,tjdi|t|tjsJ||_dSNr>)rrr8rWBuiltinMethodTyperlrrr>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_methodr6r1r{r|r}r~r-cCs@|jj}|jj}|jot|jd}t|||}|||||Sr)rlrrr=rr-r9 call_method)rur6r{r}rrQ obj_sourceobj_vtr>r>r?rs z#BuiltinMethodVariable.call_functionrrr)rrrr staticmethodrrrr>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)6LocalGeneratorObjectVariablerP inline_tracerr1c s(tjdi|||_||_||_dSr)rrrPr[r )rurPr[r r}rr>r?rs z%LocalGeneratorObjectVariable.__init__cCrr7)rPrtr>r>r?rrrz%LocalGeneratorObjectVariable.get_codecCrpr7rqrtr>r>r?rvrwz)LocalGeneratorObjectVariable.get_filenamecCrpr7rxrtr>r>r?rzrwz%LocalGeneratorObjectVariable.get_namecCstr7)rrtr>r>r?rrz)LocalGeneratorObjectVariable.get_functioncCdSNFr>rtr>r>r?rrz%LocalGeneratorObjectVariable.has_selfcC|Sr7)rzrtr>r>r?rrz%LocalGeneratorObjectVariable.__name__cCs|jjd|dS)N())rrrzrtr>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)torch._dynamo.side_effectsrtorch._dynamo.symbolic_convertr1rr current_tx_get_inline_tracergenerator_exhaustedforce_unpack_var_sequenceremaining_itemsr ListIteratorVariable reconstruct) rucodegenrr1rrr6savedisallowtemptracerr>r>r?rs   Pz(LocalGeneratorObjectVariable.reconstructcCs|j|||Sr7)rlrrr>r>r?rz&LocalGeneratorObjectVariable.bind_argscCrr7r[rtr>r>r?rrz(LocalGeneratorObjectVariable.get_globalscCrr7)rW GeneratorTypertr>r>r?rrz(LocalGeneratorObjectVariable.python_typecCs.ddlm}|jdur|||gi|_|jSNr)InliningInstructionTranslator)rr&r build_inline_tracer)rur6r&r>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)Nr inline_call)r_is_generator_exhaustedr StopIterationr rDr$ inline_call_rrrrr eval_frame skip_coderrr)rur6r!er>r>r? next_variables*    . z*LocalGeneratorObjectVariable.next_variablecCr r r>rr>r>r?has_unpack_var_sequencerz4LocalGeneratorObjectVariable.has_unpack_var_sequencercCr NTr>rr>r>r?has_force_unpack_var_sequencerz:LocalGeneratorObjectVariable.has_force_unpack_var_sequencecCs:g} z |||Wntyt|Y|Swqr7)appendr/rr)rur6rEr>r>r?rs z6LocalGeneratorObjectVariable.force_unpack_var_sequencec CsL||}z||WdSty%}z ||WYd}~dSd}~wwr7)r_raise_exception_variablerexception_handler)rur6excr!r.r>r>r?_setup_exception%s z-LocalGeneratorObjectVariable._setup_exceptioncCs|jdup |jjdkS)Nr)r instruction_pointerrtr>r>r?_is_generator_just_started.sz7LocalGeneratorObjectVariable._is_generator_just_startedcCt|jddS)NrF)rkr rtr>r>r?r)1sz4LocalGeneratorObjectVariable._is_generator_exhaustedr6rQr{r|r}r~r-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>) CALL_INTRINSIC_1throwrAr*r__InternalThrowException)r/r9rallr TypeErrorr push_manyr)rr r/r7ExceptionVariable GeneratorExitsys version_infonext_instructionopnamer RuntimeErrorrsymbolic_resultrrrrrr)rur6rQr{r}r!retvalexc_typerr>r?r4sz                   (  > z(LocalGeneratorObjectVariable.call_method)!rrrrWCodeTyperrrrrvrzrrr__repr__rrrrrr/r0builtinsboolr2rAr-rr7r9r)rrrr>r>rr?r sJ    r c@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?rWsrWcsVeZdZdZeddeffddZddZdd Z    dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_clsvtc "tjdi|||_||_dSr)rrrZrY)rurZrYr}rr>r?rs z'LocalGeneratorFunctionVariable.__init__cCs&||jjvr t||St|j|Sr7)r__dict__keysrkrZ)rurQr>r>r? __getattr__s  z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr%)rr&r')rur6r{r}r&r>r>r?_build_inline_tracers z3LocalGeneratorFunctionVariable._build_inline_tracerr6r1r{r|r}r~rr-cCsHt|js J||||}|j}|j}|j||||jdSr)rrZrrr_rrYr=)rur6r{r}r rPr[r>r>r?r s  z,LocalGeneratorFunctionVariable.call_functionr) rrrrbr r-rr^r_rrr>r>rr?rXs"   rXcs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)NrY)rrrW)rurZr}rr>r?r>s zr?r_EszHFunctionDecoratedByContextlibContextManagerVariable._build_inline_tracer)rrrrbrr_rr>r>rr?r`5s r`cseZdZdZdfdd ZdefddZdd Zd d Z      dfdd Z fddZ d d deffdd Z Z S)UserMethodVariablez$Some unsupported user-defined methodrNc s tjdd|i|||_dS)Nrlr>)rrr)rurlrr}rr>r?rVs zUserMethodVariable.__init__cCs|jjd|jd|jdS)Nrz, r)rrrlrrtr>r>r?rTZszUserMethodVariable.__repr__cCs|jgSr7)rrtr>r>r?r]rzUserMethodVariable.self_argscCrr7)rW MethodTypertr>r>r?r`rzUserMethodVariable.python_typer6r1r{r|r}r~r-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) trace_rulesrfrlrr rrrIis_root_tracerr8rNNModuleVariablerk startswithrrrr0FSDPParamGroupuse_training_stateTorchCtxManagerClassVariablerrrzr) rur6r{r}rf call_argsvar module_attrrlrr>r?rcs<    z UserMethodVariable.call_functioncstddSNr*)rrrtrr>r?rrz*UserMethodVariable.inspect_parameter_namesrQcsF|jot|j|}|dkr|jS|dkrt||j|St||S)Nr__func__)r=rrr-r9rlrr)rur6rQr=rr>r?rs zUserMethodVariable.var_getattrrr) rrrrbrrrTrrrrrrr>r>rr?rdSs" =rdc<eZdZdfdd Z      dfd d ZZS)WrappedUserMethodVariablerNc sB|dd|ddtj|j|jfi|||_||_dSNrlr)rNrrrlrwrappedcontextrurxryr}rr>r?rs   z"WrappedUserMethodVariable.__init__r6r1r{r|r}r~r-c,|j|t|||}|j||Sr7ryenterrrexitrur6r{r}rErr>r?r  z'WrappedUserMethodVariable.call_functionrrrrrrrrr>r>rr?rvrvcru)WrappedUserFunctionVariablerNc s>|dd|ddtj|jfi|||_||_dSrw)rNrrrlrxryrzrr>r?rs   z$WrappedUserFunctionVariable.__init__r6r1r{r|r}r~r-cr{r7r|rrr>r?rrz)WrappedUserFunctionVariable.call_functionrrrr>r>rr?rrrcsTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr |S|Sr7)r8r TensorVariableget_real_valuer)xr>r>r?converts z-invoke_and_store_as_constant..convertcsg|]}|qSr>r>rrrr>r?rz0invoke_and_store_as_constant..csi|] \}}||qSr>r>rrr>r?rz0invoke_and_store_as_constant..r)rBrIregister_attr_or_moduler)r6rlrQr{r}resr>rr?rsrcsxeZdZdhejZ d dfdd ZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZZS)rr[Nrc  sztjdi| t|tsJt|tjsJt|ts#J||_||_ ||_ ||_ ||_ ||_ ||_||_dSr)rrr8rrrWrSrDrrPr[r\r^r_r] wrapped_fn) rurrPr[r\r^r_r]rr}rr>r?rs z#NestedUserFunctionVariable.__init__cCrr7r>rtr>r>r?rrz$NestedUserFunctionVariable.self_argscCs |jSr7)rPrrtr>r>r?rrrwz#NestedUserFunctionVariable.get_codecCrr7rrtr>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)NrrU)r]rrWrTrPrr[rr\rfr^rXr_r8rCrYrVrDrZ)rur`r_rVr>r>r?rs&      z'NestedUserFunctionVariable.get_functioncCs |jduSr7)r]rtr>r>r? has_closure&rwz&NestedUserFunctionVariable.has_closurecCr r r>rtr>r>r?r)rz#NestedUserFunctionVariable.has_selfcCrr7r#rtr>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?r?6z7NestedUserFunctionVariable.bind_args..)rrrWrTr[rrr\rCrBrangerrr^keys_as_python_constantrXrgrrrrDrrHrIrrSrr]) rurOr{r}rPr`r5rErrQrr>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)Nra)load_import_fromrr>rr>r?I z8NestedUserFunctionVariable.reconstruct..Fc ddS)Nrwrapsrr>rr>r?rmrr*r T) add_push_nullrP extend_outputcreate_load_const_uncheckedr[r/r;rryr\create_load_constr]r^r_rrr rr)rurr_r>rr?rGsF          z&NestedUserFunctionVariable.reconstructr7r)rrrrorrrrrrrrrrrrrr>r>rr?rs$ rcsxeZdZddhejZddfdd ZddZed d Z     dddZ dddZ d d de fddZ Z S)SkipFunctionVariablerreasonNrc r[r)rrrr)rurrr}rr>r?r| zSkipFunctionVariable.__init__cCrr7rrtr>r>r?rrz'SkipFunctionVariable.as_python_constantcCs$t|s t|tj|||dSr)r'rrrFUNCTION_MATCHrr>r>r?rs z'SkipFunctionVariable.create_with_sourcer6r1r{r|r}r~r-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)2N_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)gb_typery 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. optreez*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: )rgrhrrrrr graph_breakgetrr8rWWrapperDescriptorTypeutils warn_oncerrkgetfilerGrrljoinr) rur6r{r}graph_break_msgrqualnamepathrrknown_python_builtin_modulesrr>r>r?rs              ) z"SkipFunctionVariable.call_functioncCstjt|j|Sr7)r r/r;rrrr>r>r?rrz%SkipFunctionVariable.call_obj_hasattrrQcCrr7)r#r rrnrr=rr>r>r?rs z SkipFunctionVariable.var_getattrr7rrr6r1)rrrr-rrrrrrrrrrr>r>rr?rus*  qrcsJeZdZdZdfdd 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". rNc r[r)rr wrapper_obj attr_to_trace)rurrr}rr>r?rrz$WrapperUserFunctionVariable.__init__r6r1csF||jkrt|j|j}|jot|j|}t|||St||Sr7) rrkrr=rr-r9rr)rur6rQr<r=rr>r?rs z'WrapperUserFunctionVariable.var_getattrr{r|r}r~r-cCs&ttj||t|jg||Sr7)r rr getattr_and_tracerr/rrr>r>r?rsz)WrapperUserFunctionVariable.call_functionrrr)rrrrbrrrrr>r>rr?rsrcCstjr ddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesrrr>r>r?_traceable_collective_remaps*s  rcCs>tjs Jd|tvsJ|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rrrrvaluesr import_sourcer)r6rl inner_name path_sourcer>r>r?_traceable_collectives_source5s   rcsdeZdZdZdfdd 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. rNc s,tj|fi|t|tsJ||_dSr7)rrr8rreplacement_var)rurlrr}rr>r?rIs z*CollectiveFunctionRewriteVariable.__init__r6r1cKs6t||\}}t|ft|fd|i||d|S)Nr=)rr=)rrewriter)r6old_fnr=optionsnew_fn new_sourcer>r>r?r;Nsz(CollectiveFunctionRewriteVariable.createcCst|o |tvSr7)rg isfunctionr)variabler>r>r? can_rewriteXsz-CollectiveFunctionRewriteVariable.can_rewritecCst|}|t||fSr7)rr)r6rlrr>r>r?r^s z)CollectiveFunctionRewriteVariable.rewriter{r|r}r~r-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>async_opzBCollectiveFunctionRewriteVariable can't support async_op=True for opzUnsupported all_reduce op: )torch.distributedrrrrgrrlrDrrrr all_reducereduce_scatter_tensor_reduce_scatter_baserrrdefaultrr r/r;rr) rur6r{r}distrr reduce_op_var reduce_opr>r>r?rcs2     z/CollectiveFunctionRewriteVariable.call_functionrrr) rrrrbrrr;rrrrr>r>rr?r>s$    rcs.eZdZ        d fd d ZZS) FunctoolsWrapsVariabler6r1r{r|r}r~rr-cs6|stdkrfdd}t|St||S)Nr*cs0t|tjr|jddStd|ddS)Nr)rzfunctools.wraps(r)r8r rclonerrr{r>r?rs z3FunctoolsWrapsVariable.call_function..wraps)rr LambdaVariablerr)rur6r{r}rrrr?rs  z$FunctoolsWrapsVariable.call_functionr)rrrrrr>r>rr?rsrc@s.eZdZddZ       dd d Zd S)CollectionsNamedTupleFunctioncCrr7rrtr>r>r?rrz0CollectionsNamedTupleFunction.as_python_constantr6r1r{r|r}r~rr-cCsRt||}|r#|jdd|Didd|D}tj|tdStddS)NcSg|]}|qSr>rrr>r>r?rrz?CollectionsNamedTupleFunction.call_function..cSi|] \}}||qSr>rrr>r>r?rrz?CollectionsNamedTupleFunction.call_function..) mutation_typez!namedtuple with non constant args)r!rlrBr UserDefinedClassVariabler,r)rur6r{r} constant_argsrr>r>r?rs   z+CollectionsNamedTupleFunction.call_functionNr)rrrrrr>r>r>r?rsrcseZdZdeddffdd ZddZdd Zd d Z      dddZd d de defddZ d d de fddZ ddZ ddZ ZS)FunctoolsPartialVariabler`rNc sPtjdi|||_t|tsJ||_t|tsJ||_t t |_ dSr) rrr`r8rAr{rDkeywordsrrr% fake_value)rur`r{rr}rr>r?rsz!FunctoolsPartialVariable.__init__cCrr7)rrrtr>r>r?rrz$FunctoolsPartialVariable.python_typecsfdd|j|jr|j|js)tt|jdddS|jt |j } t|t|jd|ddS)Ncr)Nrrrr>rr>r?rrz6FunctoolsPartialVariable.reconstruct..r*F) rr`r{foreachrrr rrrCr]create_call_function_kw)rurr]r>rr?rs  z$FunctoolsPartialVariable.reconstructcCr r7rrtr>r>r?rrz%FunctoolsPartialVariable.get_functionr6r1r{r|r}r~r-cCs(|j|}i|j|}|j|||Sr7)r{rr`r)rur6r{r} merged_args merged_kwargsr>r>r?rs z&FunctoolsPartialVariable.call_functionrQcCstjttt|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`r{rrcSsi|] \}}t||qSr>)r/r;rr>r>r?rsz8FunctoolsPartialVariable.var_getattr..) r=rr`r ListVariabler{rrBConstDictVariablerri)rur6rQr=rBr>r>r?rsz$FunctoolsPartialVariable.var_getattrcC:tj|jgdd|jDRidd|jDS)NcSrr>rr>r>r>r?rrz?FunctoolsPartialVariable.as_python_constant..cSrr>rrr>r>r?rrz?FunctoolsPartialVariable.as_python_constant..)rrr`rr{rrBrtr>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?rrzEFunctoolsPartialVariable.guard_as_python_constant..cSrr>rrr>r>r?rrzEFunctoolsPartialVariable.guard_as_python_constant..)rrr`rr{rrBrtr>r>r?rsz1FunctoolsPartialVariable.guard_as_python_constantr)rrrr-rrrrrrrrrrrr>r>rr?rs0     rcseZdZdddhejZeeddee de fe j ffddZ ed d Zdeddffd d Zedefd dZddZddZ        d ddZ      d!ddZddZZS)"PolyfilledFunctionVariablerlr traceable_fnNr.cCrr7r>)rr>r>r?_get_polyfill_handlers sz1PolyfilledFunctionVariable._get_polyfill_handlerscCrr)rrrrrr>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 )__torch_dynamo_polyfill____python_implementation__z# does not have a traceable functionr>) rrrlrrcallablerkrOrr)rurlr}handlercandidate_attr candidaterrr>r?rs     z#PolyfilledFunctionVariable.__init__cCrr7)rrtr>r>r? polyfill_fn/sz&PolyfilledFunctionVariable.polyfill_fncCr:)N*__torch_dynamo_can_constant_fold_through__F)rkrrtr>r>r?can_constant_fold_through3z4PolyfilledFunctionVariable.can_constant_fold_throughcCr r7rrtr>r>r?r8rz'PolyfilledFunctionVariable.get_functionr6r1r{r|r}r~r-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>rrr>r>r?rFrz.cSrr>rrr>r>r?rGrz.r*rcss@|]}t|tjrt|jtpt|tjo|tuVqdSr7)r8r r/rintSymNodeVariablerrr>r>r?r?Rs  z;PolyfilledFunctionVariable.call_function..rcss|]}|VqdSr7as_proxy)rar>r>r?r?]rcSs$g|]}t|tjr |jn|jqSr>)r8r r/rsym_numrr>r>r?ras  )r )rr"rlrBr-r9rUsumrr8r r TupleVariablerFrr;rI create_proxyrsym_sumrCrr)rur6r{r}rEtraceable_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=)rrkrlr&r=rr)rur6rQr{r}methodrpolyfilled_method_variabler>r>r?rosz&PolyfilledFunctionVariable.call_methodcCrr7rrtr>r>r?rrz-PolyfilledFunctionVariable.as_python_constantrr{r|r}r~rr-)rrrr-rrr lru_cacherDrrrWrTrrr4rpropertyrrrrrrrr>r>rr?rsD$  4 rc@seZdZddZdS)TracebackVariablecCsdSr7r>rr>r>r?rszTracebackVariable.call_functionN)rrrrr>r>r>r?rs rcs4eZdZfddZddZddZddZZS) SysFunctionVariablec stjdi|||_dSr)rrr)rurr}rr>r?rs zSysFunctionVariable.__init__cCs`t|jr|jd}|j}d}t|||t||g}ntdtdtdg}t|S)N)r exn_vt_stackrRr-r9r r/r )rur6exnrtbrBr>r>r?exc_infos     zSysFunctionVariable.exc_infocCs||jdSrs)rrBrr>r>r? exceptionr"zSysFunctionVariable.exceptioncCsB|jtjur ||S|jtjur||Std|jjdS)Nzsys.)rrKrrrrrr>r>r?rs    z!SysFunctionVariable.call_function)rrrrrrrrr>r>rr?rs  r)TMADescriptorMetadataTritonHOPifierc@seZdZdedefddZdedefddZdedefd d Z de e j j jd ffd d ZddZddZddZddZdedefddZdddeeddfddZdefddZd S)!DynamoTritonHOPifierrrcCst|r7)r)rurr>r>r?raise_unsupportedrz&DynamoTritonHOPifier.raise_unsupportedmaybe_callablecCst|ttfSr7)r8rr)rur!r>r>r? is_callablerz DynamoTritonHOPifier.is_callabler<cCs|jSr7r)rur<r>r>r? get_valuerzDynamoTritonHOPifier.get_value.cCs4ddlm}t||r|Stdt|dS)Nr*)BaseListVariablezgrid for the triton kernel is )listsr$r8rrr)rugridr$r>r>r? check_grids  zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSi|] \}}tj||qSr>r r/r;rr>r>r?rsz2DynamoTritonHOPifier.call_grid..)rBr)rur&metar6r>r>r? call_gridszDynamoTritonHOPifier.call_gridc Cs*ddlm}|||}||||}|S)Nr*)SourcelessBuilder)builderr,r;r) ruuser_fnr{r}r6rr,wrapped_user_functionrEr>r>r?call_user_defined_fns  z)DynamoTritonHOPifier.call_user_defined_fncCs*ddlm}||t|j||}|S)Nr*)VariableBuilder)r-r1r kernel_source_wrap)ruuser_objr6rrQr1wrapped_user_objr>r>r?wrap_user_defined_objs z*DynamoTritonHOPifier.wrap_user_defined_objcCs||}dd|D}|S)NcSrr>r)rconfigr>r>r?rrz=DynamoTritonHOPifier.maybe_unpack_configs..)unpack_var_sequence)ruconfigsr6r>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.)is_python_constantr r)rurEr>r>r?maybe_unpack_heuristic_results z2DynamoTritonHOPifier.maybe_unpack_heuristic_resultrTritonKernelVariabler{cCs>|jdus t|dkr|dt||j|j|d|jdS)Nr*z7Triton kernels should be called with only a single gridr)kernel kernel_idxr&r2)r&rr rr>r?r=)rurr{r>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.)rcSr(r>r)rr>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: rrr>)r?constant_args_idxr&tma_descriptor_metadatar})rhr/dictsrrAr]r8TMADescriptorVariable to_metadatadata_ptr from_tensorrB*torch._higher_order_ops.triton_kernel_wraprArBrrealizer rrr repradd_constant_argsrDrIr r?r)rurgridscombined_args_rawr6rrDrFrG combined_argsrArBrnon_constant_argsrCr*r>r.r?call_HOPsT           zDynamoTritonHOPifier.call_HOPN)rrrrrr rrVr"r#rCrfxproxyProxyr'r+r0r6r:r<rr@r/rRr>r>r>r?rs$   rcseZdZUded<ded<eeed<ded<dfd d Z      dddZ      dfdd Zde de fddZ Z S)r=r2r&r3r>r?rr2rNc s4|dd|_tjdi|t||||dS)Nr2r>)rNr2rr dynamo_triton_hopifier_singleton init_variable)rur>r?r&r}rr>r?rNszTritonKernelVariable.__init__r6r1r{r|r}r~r-cCst||||Sr7)rVcall_triton_kernelrr>r>r?rSsz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)rVr@call_runrr)rur6rQr{r}rr>r?r]s  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nr*r.)r)rhr/tensorrr8r; evaluate_expr)rurr/rr>r>r?specialize_symbolicls   z(TritonKernelVariable.specialize_symbolicrrr) rrrrZrrrrrrr^rr>r>rr?r=Hs.    r=cs>eZdZ        dfdd Zd d Zd d ZZS)rFrHvariables.DataPtrVariabledimslist[ConstantVariable] block_dims element_sizer/c s>t|tjsJtjdi|||_||_||_||_dSr) r8r DataPtrVariablerrrHr`rbrc)rurHr`rbrcr}rr>r?rws  zTMADescriptorVariable.__init__cCs(dd|jDdd|jD|jfS)NcSrr>rrdimr>r>r?rrz5TMADescriptorVariable.to_metadata..cSrr>rrer>r>r?rr)r`rbrcrrtr>r>r?rGsz!TMADescriptorVariable.to_metadatacsXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorcreate_d_tma_descriptor)rrr`r>rrur>r?rsz3TMADescriptorVariable.reconstruct..r*F) rrHrr`rbrcrrr)rurr{r>rir?rs   z!TMADescriptorVariable.reconstruct)rHr_r`rarbrarcr/)rrrrrGrrr>r>rr?rFvsrFcs@eZdZdeddffdd Z     dd dZZS)CreateTMADescriptorVariablerankrNc s(|dvsJtjdi|||_dS)N)r*r r>)rrrk)rurkr}rr>r?rs  z$CreateTMADescriptorVariable.__init__r6r1r{r|r}r~r-cCs.d|vr|dn|d}t|tjstd|jd|jdkrGt|t|dks,Jd|vr4|dn|dg}d|vrA|dn|d g}nr>r?rs6  z)CreateTMADescriptorVariable.call_functionr)rrrrrrrr>r>rr?rjs rjr7r)nrbrUrrgrYrKrWcollections.abcrtypingrrrrrtyping_extensionsr unittest.mockr rrgr r bytecode_transformationr rrr6rrrrrrrrrrrguardsrrr=rrrr rr!r"r#r$r%r&r'r(r)baser+r,r-rhr/#torch.distributed.fsdp._fully_shardr0ModuleNotFoundErrorrr1rJr2r3r4r@rHrDrrSrarjrnrorrr rWrXr`rdrvrrrrrrrrrrrrrrrrrrVr=rFrjr>r>r>r?s   4 ,       "J > 7Y "  OO#.$