o ,h'[@sldZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddlm Z ddl m Z mZmZmZmZddlmZddlmZddlmZddlZdd lmZd d lmZmZmZmZd d l m!Z!m"Z"m#Z#d d l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.d dl/m0Z0m1Z1d dl2m3Z3m4Z4m5Z5m6Z6d dl7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEddlFmGZGzddlHmIZIWn eJydZIYnwerddlKmLZLddlMmNZNddlOmPZPmQZQededZRdZSdZTeZUGdddZVde deVfd d!ZWd"d#ZXdsdtd&d'ZYdtd(d)ZZd*e[e\eEffd+d,Z]d-d.Z^hd/Z_d0d1Z`Gd2d3d3eEZaGd4d5d5eaZbGd6d7d7eaZcGd8d9d9eEZdGd:d;d;edZeGdd?d?efZgGd@dAdAebZhGdBdCdCehZiGdDdEdEebZjdtdFdGZkGdHdIdIeaZlGdJdKdKelZmGdLdMdMeEZnGdNdOdOenZoGdPdQdQeEZpGdRdSdSepZqdTdUZrdtdVdWZsGdXdYdYebZtGdZd[d[ebZuGd\d]d]ebZvGd^d_d_eEZwGd`dadaeEZxGdbdcdceEZyGdddedeeEZzddflOm{Z{m|Z|m}Z}m~Z~Gdgdhdhe~ZeZGdidjdjeEZGdkdldleEZGdmdndneEZGdodpdpeEZGdqdrdreEZdS)ua 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 FunctionType)AnyCallableOptional TYPE_CHECKINGTypeVar)Never)patch)WeakKeyDictionary)get_stack_above_dynamo)configgraph_break_hints polyfills variables)create_call_function create_rot_n is_generator) get_dynamo_observed_exceptionhandle_observed_exceptionInfiniteGeneratorErrorObservedExceptionObservedGeneratorExitObservedUserStopIterationraise_observed_exception SkipFrameunimplemented_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)#AsPythonConstantNotImplementedErrorAttributeMutationNewValueMutationNewVariableTrackerConstantVariable)_fsdp_param_group) PyCodegenInstructionTranslator)TritonGridTypeTritonKernelType_F)boundc@s(eZdZdefddZdefddZdS) FunctionSpecfunccCs|j}|j}|j|_|j|_|j|_|d|j|_||j|j|_ |j|j |_ ||j|j|j|_ |j|j}|j t @rE||nd|_||jrNdnd7}|j t@r]|||_dSd|_dS)Nr/r)__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)selfrAcodevnoffrW\/var/www/html/scripts/venv/lib/python3.10/site-packages/torch/_dynamo/variables/functions.py__init__is "zFunctionSpec.__init__cCsH|jpd|_|jp i|_tt|jt|j dtt|j|_ dSNrW) __defaults__defaults__kwdefaults__ kwdefaultsdictziprLlenrangepos_default_map)rSrArWrWrXupdate_defaults{s  $ zFunctionSpec.update_defaultsN)__name__ __module__ __qualname__rrYrdrWrWrWrXr@hsr@rAreturncCs&t|}|durt|}|t|<|SN) _spec_cachegetr@)rAspecrWrWrX _get_specs rmcCst|}||i}t|}t|jD]T\}} |t|kr(t||||| <q| |vrC| |jvr8t| dt|| | || <q| |j vrb|j | } d} |rVt || } t||j | | || <qtd| |t|jd} |j rt|t| ||j <n| rtdt|dt|j|jD]3} | |vrt|| | || <q| |jvrd} |rt || dd} t||j| | || <qtd| |jrt||||j<|S|rtdt||S) Nz is positional-onlyz&Missing required positional argument: z#Too many positional arguments: got z , expected T)is_kwz(Missing required keyword-only argument: zUnexpected keyword arguments: )rmrdr_ enumeraterLrawrap_bound_argrJ TypeErrorpoprcr$r\rPtuplerMr^rRlist)rAtx fn_sourceargskwargsrlbarem_kwinameidxdefault_sourceextrakwdefault_sourcerWrWrXbind_args_cachedsP        rrur9cCs,t|tr|S|st||Stj||Sri) isinstancer3buildrLazyVariableTrackercreate)ruvalsourcerWrWrXrps  rpcCs6t|D]\}}t|ttfrt||||<qdSri)rtitemsrrsr_rp)ruresultkvrWrWrXwrap_args_kwargss rrcCsB|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_cellrr)parentrrTrr|new_cellrWrWrX init_cellvarss  rc Csdddlm}||||||}||_t|tr"ddlm} t| |}|dus-t|ts-J||_|S)Nrrpairwise) typesrr]rrs itertoolsrr___annotations__) rT f_globalsr|r\closurer^ annotationsrrArrWrWrX_create_nested_fns    r>__doc__rB __closure__ __globals__r[r]rcCsl|ot||}zt||}Wntytt|Ynw|tvr't||}|r0tj ||St ||Sri) r"inspectgetattr_staticAttributeErrorrfn_known_dunder_attrsgetattrrrrr3r)rufnrr|subobjrWrWrXfn_var_getattrs   rc@s\eZdZddZddZ     dd dZddded efddZddZ ddZ dS)BaseUserFunctionVariablecC |jSriget_code co_filenamerSrWrWrX get_filename z%BaseUserFunctionVariable.get_filenamecCrrirco_namerrWrWrXget_namerz!BaseUserFunctionVariable.get_namerur9rwlist[VariableTracker]rxdict[str, VariableTracker]rhr3cCs||g|||Sri)inline_user_function_return self_argsrSrurwrxrWrWrX call_functionsz&BaseUserFunctionVariable.call_functionr|cCsLd}z t||}Wnty|dkrt|trd}Ynwtj|S)NFreT)hasattr get_functionNotImplementedErrorrNestedUserFunctionVariablerr5rrSrur|rrWrWrXcall_obj_hasattr's  z)BaseUserFunctionVariable.call_obj_hasattrcCstt|jSri)rtr signaturer parametersrrWrWrXinspect_parameter_names3z0BaseUserFunctionVariable.inspect_parameter_namescCiSrirWrSrurWrWrX closure_vars6z%BaseUserFunctionVariable.closure_varsNrur9rwrrxrrhr3) rerfrgrrrstrr3rrrrWrWrWrXrs*   rcseZdZdZddhejZeddZd)d*fd d Zfd d Z d dZ ddZ ddZ ddZ ddZddZdeeeffddZdddefddZdddedefd d!Z   " # $ %  &d+fd'd( ZZS),UserFunctionVariablez-Some unsupported user-defined global functionr is_constantcCt|tj|||dSNr)r! make_guardr CLOSURE_MATCHclsvaluerrWrWrXcreate_with_sourceCs z'UserFunctionVariable.create_with_sourceFrhNc srtjd i|t|ddrd|_nd|_t|tjtjj fs-t d|ddgt j dt |d|}||_dS) 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_inlinerW)superrYrrrrrtorchjitScriptFunctionrrINFERENCE_MODErrrrSrrrx __class__rWrXrYHs   zUserFunctionVariable.__init__cst|tr|jStSri)r-rrras_python_constantrrrWrXrbs  z'UserFunctionVariable.as_python_constantcCgSrirWrrWrWrXrhrzUserFunctionVariable.self_argscC|jSrirrrWrWrXrkz!UserFunctionVariable.get_functioncC|jjSri)rrBrrWrWrXrnzUserFunctionVariable.get_codecCtjSrirrrrWrWrX python_typeqrz UserFunctionVariable.python_typecCst|jddduSN__self__)rrrrWrWrXhas_selftzUserFunctionVariable.has_selfcCrri)rrrrWrWrX get_globalswrz UserFunctionVariable.get_globalsc CsV|jrJ|j}t|tstd|jj}t|||j||}t |||j |jj p*d}t |t |jj j ks8Jtt|jj j |D]e\}} } |jj} | | vrU| | } nO|jrtt|jd|} t| d}z t|| j|}Wn ty}t}Ynw| | | |} nz t|| j}Wn tyt}Ynw| d| |} | || <qC|S)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.rWr cell_contentsN)rrrrrqrroot_txrrrrBrra co_freevarsr`rcountrr%r"r3rr ValueErrorrDeletedVariabletrack_cell_existing)rSrrwrxrrrrr}r|cellrcell_var closure_cellclosure_cell_contents contents_varrWrWrX bind_argszsL           zUserFunctionVariable.bind_argsrur9r|cC&|tvr t||St||j|j|Sri)r(rGetAttrVariablerrrrSrur|rWrWrX var_getattrs z UserFunctionVariable.var_getattrcCst|j|}tj|Sri)rrrr5rrrWrWrXrs  z%UserFunctionVariable.call_obj_hasattrrwrrxrr3c sl|jtjjur?z dd|D}dd|D}tjj|i|j}t|WSty>}z t d|d||d}~ww|jtjj urt |jj |i|}|jd} t| ts}| } d| jd } td d |jd |d |d | gtjdt| ts| } d| d} td|| d| ddgd| j} tj| ddS|jrt||j|||S|jjjs|jtjjj urtjj!"|t#$|||WdS1swY|jjj%r.|jjj&s.zddl'm(}Wn t)yd}Ynw|dur.|j|j*|j+fvr.tjj!&|t#$|||WdS1s)wYt#$|||S)NcSg|]}|qSrWr.0argrWrWrX z6UserFunctionVariable.call_function..cSi|] \}}||qSrWr)rkeyrrWrWrX sz6UserFunctionVariable.call_function..zCannot convert patch_dynamo_config args/kwargs to constants. Please fix your call to patch_dynamo_config by using simpler inputs. args: z , kwargs: 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` regionTnonstrict_traceable) FSDPState),rr_dynamopatch_dynamo_configrchangesrDynamoConfigPatchVariabler0 RuntimeErrornonstrict_tracerrbindrwrrrrerrr USER_ERRORrrTorchInGraphFunctionVariablerinvoke_and_store_as_constantrcurrent_tracer,unsafe_allow_externally_visible_side_effectsutils8_disable_side_effect_safety_checks_for_current_subtracerr2allow_externally_visible_side_effects_in_subtracerrrunder_activation_checkpoint#allow_side_effects_under_checkpoint/torch.distributed.fsdp._fully_shard._fsdp_stater Exception _pre_forward _post_forward)rSrurwrx args_const kwargs_constrer=fn_vartypmsgfn_namerrrrWrXrs         "z"UserFunctionVariable.call_functionFrhNr)rerfrgrr_nonvar_fields classmethodrrYrrrrrrrr_rr3rrrr __classcell__rWrWrrXr:sF  7 rcsFeZdZddfdd ZeddZ   dddZZS)BuiltinMethodVariableFrhNc s,tjdi|t|tjsJ||_dSrZ)rrYrrBuiltinMethodTyperrrrWrXrYs zBuiltinMethodVariable.__init__cCs0|j}|j}|tur|dkpt|tuo|dkS)N__new__ __contains__)rrerstype frozenset)obj method_self method_namerWrWrXis_supported_builtin_methods z1BuiltinMethodVariable.is_supported_builtin_methodrur9rwrrxrr3cCs@|jj}|jj}|jot|jd}t|||}|||||Sr)rrrerr"r3r call_method)rSrurwrxr<r| obj_sourceobj_vtrWrWrXr%s z#BuiltinMethodVariable.call_functionr0r1r)rerfrgrY staticmethodr>rr4rWrWrrXr5s  r5c seZdZdejdedffdd ZddZdd Zd d Z d d Z ddZ ddZddZ e Z d;ddZddZddZddZddZd d!Zd"d#Zd$ejfd%d&Zd$eefd'd(Zds  z;LocalGeneratorObjectVariable.call_method..closeTrW) CALL_INTRINSIC_1throwrzr/r__InternalThrowException)rhrsraallrrqrQ push_manyrcrRrr5rqExceptionVariable GeneratorExitsys version_infonext_instructionopnamerrrsymbolic_resultrr9r&rrr?)rSrur|rwrxrZretvalexc_typerrWrXr?sz                   (  > z(LocalGeneratorObjectVariable.call_methodrJr7r1)"rerfrgrCodeTyperrYrrrrrrI__repr__rVrrrrQrhribuiltinsboolrkrtr3rSrlrqrsrcrr?r4rWrWrrXrC2sL     rCc@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)rerfrgrrWrWrWrXrrsrcsVeZdZdZeddeffddZddZdd Z    dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_clsvtc "tjdi|||_||_dSrZ)rrYrr)rSrrrxrrWrXrYs z'LocalGeneratorFunctionVariable.__init__cCs&||jjvr t||St|j|Sri)r__dict__keysrr)rSr|rWrWrX __getattr__s  z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr^)rOr_r`)rSrurwrxr_rWrWrX_build_inline_tracers z3LocalGeneratorFunctionVariable._build_inline_tracerrur9rwrrxrrhr3cCsHt|js J||||}|j}|j}|j||||jdSr)rrrrrrr)rSrurwrxrDrTrrWrWrXrs  z,LocalGeneratorFunctionVariable.call_functionr) rerfrgrrCr3rYrrrr4rWrWrrXrs"   rcs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)Nr)rrYr)rSrrxrrWrXrYs zA z7WrappedUserMethodVariable.reconstruct..r/F add_push_nullr extend_outputrrSrJrWrrXrV@ z%WrappedUserMethodVariable.reconstructr1rrerfrgrYrrVr4rWrWrrXr- rcr)WrappedUserFunctionVariablerhNc s2|ddtj|jfi|||_||_dS)Nr)rrrrYrrrrrrWrXrYGs  z$WrappedUserFunctionVariable.__init__rur9rwrrxrr3crrirrrrWrXrMrz)WrappedUserFunctionVariable.call_functioncr)NcrrirrWrrWrXrYrz9WrappedUserFunctionVariable.reconstruct..r/FrrrWrrXrVXrz'WrappedUserFunctionVariable.reconstructr1rrrWrWrrXrFs rcsTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr |S|Sri)rrTensorVariableget_real_valuer)xrWrWrXconvert_s z-invoke_and_store_as_constant..convertcsg|]}|qSrWrWrrrrWrXr dr z0invoke_and_store_as_constant..csi|] \}}||qSrWrWrrrrrWrXr ez0invoke_and_store_as_constant..r)rrregister_attr_or_moduler#)rurr|rwrxresrWrrXr^srcseZdZdhejZ d$ d%fdd ZddZdd Zd d Zd d Z ddde de fddZ fddZ ddZ fddZddZddZddZd&d"d#ZZS)'rrNrhc  s| ddur| jtdtjdi| t|ts Jt|tj s*Jt|t s1J||_ ||_ ||_ ||_||_||_||_||_dS)N mutation_typerrW)rkupdater1rrYrrrrrr_r/rTrr\r^rr wrapped_fn) rSr/rTrr\r^rrrrxrrWrXrYts z#NestedUserFunctionVariable.__init__cCrrirWrrWrWrXrrz$NestedUserFunctionVariable.self_argscCs |jSri)rTrrrWrWrXrrz#NestedUserFunctionVariable.get_codecCrrirrrWrWrXrrz&NestedUserFunctionVariable.python_typecCs|jrtt|j|j|j}|jr|j|_ |j r%|j |_ |j rH|j }t |tr>ddlm}t||}t |tsEJ||_|S)Nrr)rrrrrTrrr/r\r[r^r]rrrsrrr_r)rSrArrrWrWrXrs&      z'NestedUserFunctionVariable.get_functionrur9name_varrcCs|jj||j|tdSri)rr store_attrrr5)rSrurrrWrWrX call_setattrsz'NestedUserFunctionVariable.call_setattrcs,|dkr |j|g|RSt||||S)N __setattr__)rrr?rSrur|rwrxrrWrXr?sz&NestedUserFunctionVariable.call_methodcCs |jduSri)rrrWrWrX has_closurerz&NestedUserFunctionVariable.has_closurecs |dkr |jSt||S)Nre)r/rr const_getattrrrrWrXrs z(NestedUserFunctionVariable.const_getattrcCrErFrWrrWrWrXrrz#NestedUserFunctionVariable.has_selfcCrrir\rrWrWrXrrz&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|]}tdVqdSri)r.)r_rWrWrXrxz7NestedUserFunctionVariable.bind_args..)rrrrr/rr\rsrrbrarr^keys_as_python_constantr]rrrapply_defaultsr_ argumentsrrrrror) rSrrwrxrTrAr=rr}r|rrWrWrXrs(     z$NestedUserFunctionVariable.bind_argsrJr7csfdd|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|jtddtdtddd d lm}|}|jj|r|jjj|D]\}}|td|qdSdS) Ncs tdS)Nr)load_import_fromrerWrJrWrXr z8NestedUserFunctionVariable.reconstruct..Fc ddS)N functoolswrapsrrWrrWrXr rr/rTrr8)rrTrcreate_load_const_uncheckedrr5rrrr\create_load_constrr^rrrrrrrOr9rPrrhas_pending_mutationstore_attr_mutationsrdup_topr)rSrJrr9rur|rrWrrXrVs`             z&NestedUserFunctionVariable.reconstructrir1r)rerfrgrr2rYrrrrr3rr?rrrrrrVr4rWrWrrXrns6   rcr)!WrappedNestedUserFunctionVariablerhNc s|dd|dd|dd|dd|dd|dd|dd|ddt|j|j|j|j|j|j|j |j ||_ ||_ dS) Nr/rTrr\r^rrr) rrrrYr/rTrr\r^rrrrrrrrWrXrY"s(         z*WrappedNestedUserFunctionVariable.__init__rur9rwrrxrr3crrirrrrWrXr8rz/WrappedNestedUserFunctionVariable.call_functioncr)NcrrirrWrrWrXrDrz?WrappedNestedUserFunctionVariable.reconstruct..r/FrrrWrrXrVCrz-WrappedNestedUserFunctionVariable.reconstructr1rrrWrWrrXr!s rcsxeZdZddhejZddfdd ZddZed d Z     dddZ dddZ d d de fddZ Z S)SkipFunctionVariablerreasonNrhc rrZ)rrYrr)rSrrrxrrWrXrYP zSkipFunctionVariable.__init__cCrrirrrWrWrXrUrz'SkipFunctionVariable.as_python_constantcCs$t|s t|tj|||dSr)r,r!rr FUNCTION_MATCHrrWrWrXrXs z'SkipFunctionVariable.create_with_sourcerur9rwrrxrr3c Cst|jddr&t|jdd}tdt|jd|jd|ddgd dS|jtjjurN|d d}|r9| }td d |d |dd|dgd dS|jtjj urh|d d}|ra| }t d|t j rddlm}|||j}t|ts||||St|jdd} t|jdd} | durdnt| } z&t|j} d| d| d} d| dg}d| vr|d| dd g7}Wnaty#d!d"h}| |vrd#| d$| d} d%d&g}nA| dur| d'rd(| d$| d$} d)g}tjj| d*d*|nd+| d$| d,} d-d.g}tjj| d*d*|Ynw| d/kr-d0} g}|jr4|jnd1}td2d3| d4| d5|| |d dS)6N_torchdynamo_disableF_torchdynamo_disable_msgz1Skip calling `torch.compiler.disable()`d functionzSkip calling function `z>` since it was wrapped with `torch.compiler.disable` (reason: rz(Remove the `torch.compiler.disable` callrr.z%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.z9Skip frame due to `torch._dynamo.skip_frame()`. Message: r/SourcelessBuilderrgzrfzz?Dynamo developers have intentionally marked that the function `z ` in file `z` should not be traced.zAvoid calling the function `z`.rz: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. 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: )rrrrrrr graph_breakrkr skip_framerrdont_skip_tracingbuilderrrrrrrgetfilerqrr  warn_oncejoinr)rSrurwrxr.graph_break_msgskip_frame_msgr rebuilt_fnqualname module_or module_namepathrrknown_python_builtin_modulesrrWrWrXras            & z"SkipFunctionVariable.call_functioncCstjt|j|Sri)rr5rrrrrWrWrXrrz%SkipFunctionVariable.call_obj_hasattrr|cCrri)r(rrrrrrrWrWrXrs z SkipFunctionVariable.var_getattrrir1rrur9)rerfrgr3r2rYrr3rrrrrr4rWrWrrXrIs*  xrcr)WrappedSkipFunctionVariablerhNc sD|dd|ddtj|jfd|ji|||_||_dS)Nrr)rrrrYrrrrrrrWrXrYs   z$WrappedSkipFunctionVariable.__init__rur9rwrrxrr3crrirrrrWrXrrz)WrappedSkipFunctionVariable.call_functioncr)NcrrirrWrrWrXrrz9WrappedSkipFunctionVariable.reconstruct..r/FrrrWrrXrVrz'WrappedSkipFunctionVariable.reconstructr1rrrWrWrrXrrrcsReZdZdZdfdd Zdfdd Zd d 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". rhNc rrZ)rrY wrapper_obj attr_to_trace)rSrrrxrrWrXrYrz$WrapperUserFunctionVariable.__init__rur9csF||jkrt|j|j}|jot|j|}t|||St||Sri) rrrrr"r3rrr)rSrur|rrrrWrXr s z'WrapperUserFunctionVariable.var_getattrcCrrirWrrWrWrXrrz%WrapperUserFunctionVariable.self_argsrwrrxrr3c Cs t|jdrmt|j|jd}t|ddpd}|jdddddkrmd }tjj|tjjj d }| t j rmtj j}t|}|d j|d jf} dt|} d | dd | dd} | t| 7} || ||} ttj||t|jg| |S)N cache_inforfrrr/)maxsplitrraDynamo detected a call to a `functools.lru_cache`-wrapped function. 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.z torch._dynamoz)call to a lru_cache wrapped function at: :r)rrrrsplitrrr rlogging getLogger isEnabledForDEBUG_guardsTracingContext extract_stackr filenamelinenor traceback format_listrdebugrrrrgetattr_and_tracerr5) rSrurwrx target_fnr r. dynamo_logger user_stack frame_locuser_stack_formatteduser_stack_traceall_argsrWrWrXrs4       z)WrapperUserFunctionVariable.call_functionr1rr) rerfrgrrYrrrr4rWrWrrXrsrcs*eZdZdZdfdd ZddZZS) 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. rhNc s tj||fi|||_dSrir)rSrrself_objrxrrWrXrYDrz"WrapperUserMethodVariable.__init__cCrrirrrWrWrXrHrz#WrapperUserMethodVariable.self_argsr1)rerfrgrrYrr4rWrWrrXr.=sr.cCstjr ddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesr1r0rWrWrX_traceable_collective_remapsLs  r5cCs>tjs Jd|tvsJ|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rr2r3r5valuesre import_sourcer")rur inner_name path_sourcerWrWrX_traceable_collectives_sourceWs   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. rhNc s,tj|fi|t|tsJ||_dSri)rrYrrreplacement_var)rSrr<rxrrWrXrYks z*CollectiveFunctionRewriteVariable.__init__rur9cKs6t||\}}t|ft|fd|i||d|S)Nr)r<r)r;rewriter)ruold_fnroptionsnew_fn new_sourcerWrWrXrpsz(CollectiveFunctionRewriteVariable.createcCst|o |tvSri)r isfunctionr5)variablerWrWrX can_rewritezsz-CollectiveFunctionRewriteVariable.can_rewritecCst|}|t||fSri)r5r:)rurr@rWrWrXr=s z)CollectiveFunctionRewriteVariable.rewriterwrrxrr3c Csddlm}ddlm}t|j}t|j|i|j }d}d|vrA|d rAt d|jd|d|d|jgt j d |j|j|j|jfvrs|d }|durX|jn|jd j}||vritd |tj|||d <|j|||S) Nr)REDUCE_OP_TO_STRrWasync_opz)async_op=True for distributed collectivesz, args= , kwargs=z3`torch.compile` doesn't support `async_op=True for ropzUnsupported all_reduce op: )torch.distributedr2r4rErrrr_rrrrr SUPPORTABLE all_reducereduce_scatter_tensor_reduce_scatter_baserkrrdefaultrrr5rr<r) rSrurwrxdistrEr reduce_op_var reduce_oprWrWrXrs<      z/CollectiveFunctionRewriteVariable.call_functionr1rr) rerfrgrrYrBrrDr=rr4rWrWrrXr;`s$    r;cs.eZdZ        d fd d ZZS) FunctoolsWrapsVariablerur9rwrrxrrhr3cs6|stdkrfdd}t|St||S)Nr/cs8t|tjr|jddStd|dgtjddS)Nr)rzfunctools.wrapsz]`torch.compile` can't trace `functools.wraps` on functions defined outside the compile regionr)rrrclonerrrJrrwrWrXrs  z3FunctoolsWrapsVariable.call_function..wraps)rarLambdaVariablerr)rSrurwrxrrrTrXrs  z$FunctoolsWrapsVariable.call_functionr)rerfrgrr4rWrWrrXrRsrRc@s.eZdZddZ       dd d Zd S)CollectionsNamedTupleFunctioncCrrirrrWrWrXrrz0CollectionsNamedTupleFunction.as_python_constantrur9rwrrxrrhr3cCslt||}|r#|jdd|Didd|D}tj|tdStdd|d|d gtjd dS) NcSrrWrrrWrWrXr r z?CollectionsNamedTupleFunction.call_function..cSr rWrrrWrWrXr rz?CollectionsNamedTupleFunction.call_function..rznamedtuple constructionzargs=rGz?`torch.compile` only support certain input types for namedtupler) r&rrrUserDefinedClassVariabler2rrrJ)rSrurwrx constant_argsrrWrWrXrs$   z+CollectionsNamedTupleFunction.call_functionNr)rerfrgrrrWrWrWrXrVsrVcseZdZdeddffdd ZddZd d d Zd d Z        d!ddZddde defddZ ddde fddZ ddZ ddZ ZS)"FunctoolsPartialVariablerArhNc sPtjdi|||_t|tsJ||_t|tsJ||_t t |_ dSrZ) rrYrArrtrwr_keywordsrpartialr* fake_value)rSrArwrZrxrrWrXrYsz!FunctoolsPartialVariable.__init__cCrri)rr[rrWrWrXrrz$FunctoolsPartialVariable.python_typerJr7csfdd|j|jr|j|js)tt|jdddS|jt |j } t|t|jd|ddS)Ncr)Nrr[rrWrrWrXrrz6FunctoolsPartialVariable.reconstruct..r/F) rrArwforeachrZrrrar6rsrcreate_call_function_kw)rSrJrrWrrXrVs  z$FunctoolsPartialVariable.reconstructcCrGrirrrWrWrXr rz%FunctoolsPartialVariable.get_functionrur9rwrrxrr3cCs(|j|}i|j|}|j|||Sri)rwrZrAr)rSrurwrx merged_args merged_kwargsrWrWrXr s z&FunctoolsPartialVariable.call_functionr|cCstjttt|Sri)rr5rrrr[r*rrWrWrXrsz)FunctoolsPartialVariable.call_obj_hasattrcCs|jot|j|}|dkr|jS|dkrtj|j|dS|dkr1dd|jD}tj||dS|t vr;t ||St t |dS)NrArwrrZcSsi|] \}}t||qSrW)r5rrrWrWrXr &sz8FunctoolsPartialVariable.var_getattr..) rr"rAr ListVariablerwrZrConstDictVariabler(rrr)rSrur|rrrWrWrXrs z$FunctoolsPartialVariable.var_getattrcC:tj|jgdd|jDRidd|jDS)NcSrrWrrrWrWrXr /r z?FunctoolsPartialVariable.as_python_constant..cSr rWrrrWrWrXr 0rz?FunctoolsPartialVariable.as_python_constant..)rr[rArrwrZrrrWrWrXr,sz+FunctoolsPartialVariable.as_python_constantcCrc)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantscSrrWguard_as_python_constant)rrrWrWrXr 7r zEFunctoolsPartialVariable.guard_as_python_constant..cSr rWrdrrWrWrXr 8rzEFunctoolsPartialVariable.guard_as_python_constant..)rr[rArerwrZrrrWrWrXre3sz1FunctoolsPartialVariable.guard_as_python_constantrr)rerfrgr3rYrrVrrrrrrrer4rWrWrrXrYs0    rYcseZdZdddhejZeejdee de fe j ffddZ edd Zdedd ffd d Zedefd dZddZddZ        d ddZ      d!ddZddZZS)"PolyfilledFunctionVariablerr traceable_fnrh.cCrrirW)rrWrWrX_get_polyfill_handlersDsz1PolyfilledFunctionVariable._get_polyfill_handlerscCrr)r!rr rrrWrWrXrIs z-PolyfilledFunctionVariable.create_with_sourceNc 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 functionrW) rrYrrhrkcallablerrrrg)rSrrxhandlercandidate_attr candidatergrrWrXrYOs     z#PolyfilledFunctionVariable.__init__cCrri)rgrrWrWrX polyfill_fnfsz&PolyfilledFunctionVariable.polyfill_fncCrt)N*__torch_dynamo_can_constant_fold_through__F)rrrrWrWrXcan_constant_fold_throughjz4PolyfilledFunctionVariable.can_constant_fold_throughcCrGrirrrWrWrXrorz'PolyfilledFunctionVariable.get_functionrur9rwrrxrr3c 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) NcSrrWrrrWrWrXr }r z.cSr rWrrrWrWrXr ~rz.r/rcss@|]}t|tjrt|jtpt|tjo|tuVqdSri)rrr5rintSymNodeVariablerrrWrWrXrxs  z;PolyfilledFunctionVariable.call_function..rcss|]}|VqdSrias_proxy)rarWrWrXrxrcSs$g|]}t|tjr |jn|jqSrW)rrr5rsym_numrrWrWrXr s  )rx)rqr'rrr3rrsumrarrra TupleVariablerrtrr create_proxyrsym_sumrsrgr)rSrurwrxrtraceable_function_variablerWrWrXrrsH      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)rrrr+rr"rf)rSrur|rwrxmethodr?polyfilled_method_variablerWrWrXr?sz&PolyfilledFunctionVariable.call_methodcCrrirrrWrWrXrrz-PolyfilledFunctionVariable.as_python_constantrrwrrxrrhr3)rerfrgr3r2r3rcacher_rrrrrhrr<rYpropertyrorqrrr?rr4rWrWrrXrf<sD$  4 rfc@seZdZddZdS)TracebackVariablecCsdSrirWrrWrWrXrszTracebackVariable.call_functionNrerfrgrrWrWrWrXrs rcs4eZdZfddZddZddZddZZS) SysFunctionVariablec stjdi|||_dSrZ)rrYr)rSrrxrrWrXrYs zSysFunctionVariable.__init__cCs`t|jr|jd}|j}d}t|||t||g}ntdtdtdg}t|S)Nr)ra exn_vt_stackrr3rrr5rz)rSruexnr-tbrrWrWrXexc_infos     zSysFunctionVariable.exc_infocCs||jdSr)rrrrWrWrX exceptionr[zSysFunctionVariable.exceptioncCs0|jtjur ||S|jtjusJ||Sri)rrrrrrWrWrXrs   z!SysFunctionVariable.call_function)rerfrgrYrrrr4rWrWrrXrs  r) create_tma_experimental_metadatacreate_tma_stable_metadataTMADescriptorMetadataTritonHOPifierc@seZdZdedefddZdedefddZdedefd d Z de e j j jd ffd d ZddZddZddZddZdedefddZdddeeddfddZdefddZd S)!DynamoTritonHOPifierr.rhcCst|ri)r)rSr.rWrWrXraise_unsupportedrz&DynamoTritonHOPifier.raise_unsupportedmaybe_callablecCst|ttfSri)rrr)rSrrWrWrX is_callablerrz DynamoTritonHOPifier.is_callablercCs|jSrir)rSrrWrWrX get_valuerzDynamoTritonHOPifier.get_value.cCsBddlm}t||r|Stddt|dgtjddS)Nr/)BaseListVariablez/unsupported grid type for triton hop check_gridz grid type = z;`torch.compile` only supports list-like grid for check_gridr)listsrrrvrr9rrJ)rSgridrrWrWrX check_grids    zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSi|] \}}tj||qSrWrr5rrrWrWrXr sz2DynamoTritonHOPifier.call_grid..)rr)rSrmetarurWrWrX call_gridszDynamoTritonHOPifier.call_gridc Cs*ddlm}|||}||||}|S)Nr/r)rrrr) rSuser_fnrwrxrurCrwrapped_user_functionrrWrWrXcall_user_defined_fn s  z)DynamoTritonHOPifier.call_user_defined_fncCs*ddlm}||t|j||}|S)Nr/)VariableBuilder)rrr" kernel_source_wrap)rSuser_objrurCr|rwrapped_user_objrWrWrXwrap_user_defined_objs z*DynamoTritonHOPifier.wrap_user_defined_objcCs||}dd|D}|S)NcSrrWrd)rrrWrWrXr  r z=DynamoTritonHOPifier.maybe_unpack_configs..)unpack_var_sequence)rSconfigsrurWrWrXmaybe_unpack_configss z)DynamoTritonHOPifier.maybe_unpack_configsrcCs|s |d|S)Nz`@triton.heuristics must return constant values because configs can only contain constant values.)is_python_constantrre)rSrrWrWrXmaybe_unpack_heuristic_result$s z2DynamoTritonHOPifier.maybe_unpack_heuristic_resultrCTritonKernelVariablerwcCs>|jdus t|dkr|dt||j|j|d|jdS)Nr/z7Triton kernels should be called with only a single gridr)kernel kernel_idxrr)rrarr9rrr)rSrCrwrWrWrX call_getitem.sz!DynamoTritonHOPifier.call_getitemc s*ddlmddlm}i}t|D]}||}t|ttfr-| ||<| ||<qdd| D} ddl m } m} fdd| D} fd d| D} | D]}|}t|tjtjfss|d t|d qY| | }|| t}|jd | d |j||||dtdS)Nr/r4)rbcSrrWrrrWrWrXr Ss z1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSrW)rrrr4rWrXr `s cs i|] \}}t|s||qSrW)rrr4rWrXr es z.Unexpected argument type for a Triton kernel: rrrW)rconstant_args_idxrtma_descriptor_metadatarx)rr5dictsrbrtrr!TMADescriptorExperimentalVariableTMADescriptorStableVariable to_metadata get_tensorr*torch._higher_order_ops.triton_kernel_wraprrr6realizerrrtrrepradd_constant_argsr_rr{rrv)rSrCgridscombined_args_rawrurbrrr combined_argsrrrXnon_constant_argsrrrWr4rXcall_HOP@sX          zDynamoTritonHOPifier.call_HOPN)rerfrgrr rrrrrrsrfxproxyProxyrrrrrrrrr5rrWrWrWrXrs$   rcseZdZUded<ded<eeed<ded<dfd d Z      dddZ      dfdd Zde de fddZ Z S)rr:rr;rrr"rrhNc s4|dd|_tjdi|t||||dS)NrrW)rrrrrY dynamo_triton_hopifier_singleton init_variable)rSrrrrxrrWrXrYszTritonKernelVariable.__init__rur9rwrrxrr3cCst||||Sri)rcall_triton_kernelrrWrWrXrsz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)rrcall_runrr?rrrWrXr?s  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nr/r4)rt)rr5tensorrtrr evaluate_expr)rSrr5rtrWrWrXspecialize_symbolics   z(TritonKernelVariable.specialize_symbolicr1rr) rerfrgrrrsrYrr?rrr4rWrWrrXrs.    rcsHeZdZ        dfdd Zd d ZdddZddZZS)rdata_ptrvariables.DataPtrVariabledimslist[ConstantVariable] block_dims element_sizer5c s>t|tjsJtjdi|||_||_||_||_dSrZ) rrDataPtrVariablerrYrrrr)rSrrrrrxrrWrXrYs  z*TMADescriptorExperimentalVariable.__init__cCs*tdd|jDdd|jD|jS)NcSrrWrurdimrWrWrXr r zATMADescriptorExperimentalVariable.to_metadata..cSrrWrurrWrWrXr r )rrrrrvrrWrWrXrs z-TMADescriptorExperimentalVariable.to_metadatarJr7csXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorcreate_d_tma_descriptor)rrarrWrrWrXrsz?TMADescriptorExperimentalVariable.reconstruct..r/F) rrrVrrrr]rra)rSrJrwrWrrXrVs   z-TMADescriptorExperimentalVariable.reconstructcCrri)r from_tensorrrWrWrXrrz,TMADescriptorExperimentalVariable.get_tensor)rrrrrrrr5rrerfrgrYrrVrr4rWrWrrXrs  rcsBeZdZ    dfdd ZddZdd d ZdddZZS)rrvariables.TensorVariable block_shapevariables.ListVariablec s2t|tjsJtjdi|||_||_dSrZ)rrrrrYrr)rSrrrxrrWrXrYs z$TMADescriptorStableVariable.__init__cCst|jSri)rrrvrrWrWrXrrrz'TMADescriptorStableVariable.to_metadatarJr7cs@fddd|j|jddS)Ncr)Nztriton.tools.tensor_descriptorTensorDescriptorrrWrrWrXrsz9TMADescriptorStableVariable.reconstruct..rr)r load_methodrrVrr?rrWrrXrVs    z'TMADescriptorStableVariable.reconstructrhcCrri)rrrWrWrXrrz&TMADescriptorStableVariable.get_tensor)rrrrr)rhrrrWrWrrXrs  rcs@eZdZdeddffdd Z     dd dZZS)'CreateTMADescriptorExperimentalVariablerankrhNc s(|dvsJtjdi|||_dS)N)r/rrW)rrYr)rSrrxrrWrXrY s  z0CreateTMADescriptorExperimentalVariable.__init__rur9rwrrxrr3cCs.d|vr|dn|d}t|tjstd|jd|jdkrGt|t|dks,Jd|vr4|dn|dg}d|vrA|dn|d g}nr block_dimrdim1dim0 block_dim1rz block_dim0rr)rrrr)rrrrrrar)rSrurwrxrrrrrWrWrXr s6  z5CreateTMADescriptorExperimentalVariable.call_functionr)rerfrgrsrYrr4rWrWrrXrs rc@s&eZdZ        d d d Zd S) !CreateTMADescriptorStableVariablerur9rwrrxrrhr3cCs<d|vr|dn|d}d|vr|dn|d}t||dS)Nrrrr/)rr)r)rSrurwrxrrrWrWrXr5 s z/CreateTMADescriptorStableVariable.call_functionNrrrWrWrWrXr4 srrir)rrrrrrrr#rcollections.abcrrtypingrrrrr typing_extensionsr unittest.mockr weakrefr rtorch._dynamo.excr rrrrrbytecode_transformationrrrrprrrrrrrrrrguardsr r!rr"r#r$r%r r&r'r(r)r*r+r,r-r.baser0r1r2r3rr5#torch.distributed.fsdp._fully_shardr6ModuleNotFoundErrortorch._dynamo.codegenr7rOr9rr:r;r<rOrQrjr@rmrrprr_rrrrrrrr5rCrrrrrrrrrrrrr.r5r:r;rRrVrYrfrrrrrrrrrrrrrrWrWrWrXs      0 ,      5  "[ B 7Y 4(A  TQ!.'!5