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_kwonlyargcountZ kwonly_count posonly_namesZpos_or_kw_names all_pos_names kwonly_namesco_flags CO_VARARGS varargs_nameCO_VARKEYWORDS varkw_name)selfrAcodeZvnoffrTg/home/www/facesmatcher.com/frenv_anti/lib/python3.10/site-packages/torch/_dynamo/variables/functions.py__init__is "zFunctionSpec.__init__cCsH|jpd|_|jp i|_tt|jt|j dtt|j|_ dSNrT) __defaults__defaults__kwdefaults__ kwdefaultsdictziprJlenrangepos_default_map)rQrArTrTrUupdate_defaults{s  $ zFunctionSpec.update_defaultsN)__name__ __module__ __qualname__rrVrarTrTrTrUr@hsr@rAreturncCs&t|}|durt|}|t|<|SN) _spec_cachegetr@)rAspecrTrTrU _get_specs rjcCst|}||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)Zis_kwz(Missing required keyword-only argument: zUnexpected keyword arguments: )rjrar\ enumeraterJr^wrap_bound_argrI TypeErrorpopr`r$rYrNtuplerKr[rPlist)rAtxZ fn_sourceargskwargsribaZrem_kwinameidxZdefault_sourceextraZkwdefault_sourcerTrTrUbind_args_cachedsP        ryrqr9cCs,t|tr|S|st||Stj||Srf) isinstancer3buildrLazyVariableTrackercreate)rqvalsourcerTrTrUrls  rlcCs6t|D]\}}t|ttfrt||||<qdSrf)rpitemsrzror\rl)rqresultkvrTrTrUwrap_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_cellvarsZtrack_cell_newZ store_cellrn)parentrrRrrvZnew_cellrTrTrU init_cellvarss  rc Csdddlm}||||||}||_t|tr"ddlm} t| |}|dus-t|ts-J||_|S)Nrrpairwise) typesrrZrzro itertoolsrr\__annotations__) rR f_globalsrvrYclosurer[ annotationsrrArrTrTrU_create_nested_fns    r> __globals__rB__doc__rZrrX __closure__cCsl|ot||}zt||}Wntytt|Ynw|tvr't||}|r0tj ||St ||Srf) r"inspectgetattr_staticAttributeErrorrfn_known_dunder_attrsgetattrrr|r}r3r{)rqfnrrvZsubobjrTrTrUfn_var_getattrs   rc@s\eZdZddZddZ     dd dZddded efddZddZ ddZ dS)BaseUserFunctionVariablecC |jSrfget_code co_filenamerQrTrTrU get_filename z%BaseUserFunctionVariable.get_filenamecCrrfrco_namerrTrTrUget_namerz!BaseUserFunctionVariable.get_namerqr9rrlist[VariableTracker]rsdict[str, VariableTracker]rer3cCs||g|||Srf)Zinline_user_function_return self_argsrQrqrrrsrTrTrU call_functionsz&BaseUserFunctionVariable.call_functionrvcCsLd}z t||}Wnty|dkrt|trd}Ynwtj|S)NFrbT)hasattr get_functionNotImplementedErrorrzNestedUserFunctionVariablerr5r}rQrqrvrrTrTrUcall_obj_hasattr's  z)BaseUserFunctionVariable.call_obj_hasattrcCstt|jSrf)rpr signaturer parametersrrTrTrUinspect_parameter_names3z0BaseUserFunctionVariable.inspect_parameter_namescCiSrfrTrQrqrTrTrU closure_vars6z%BaseUserFunctionVariable.closure_varsNrqr9rrrrsrrer3) rbrcrdrrrstrr3rrrrTrTrTrUrs*   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 Z CLOSURE_MATCHclsvaluerrTrTrUcreate_with_sourceCs z'UserFunctionVariable.create_with_sourceFreNc srtjd i|t|ddrd|_nd|_t|tjtjj fs-t d|ddgt j dt |d|}||_dS) NZ_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` regionZgb_typecontext explanationhintsZ_torchdynamo_inlinerT)superrVrrrzrrtorchZjitZScriptFunctionrrZINFERENCE_MODErrrrQrrrs __class__rTrUrVHs   zUserFunctionVariable.__init__cst|tr|jStSrf)r-rrras_python_constantrrrTrUrbs  z'UserFunctionVariable.as_python_constantcCgSrfrTrrTrTrUrhrzUserFunctionVariable.self_argscC|jSrfrrrTrTrUrkz!UserFunctionVariable.get_functioncC|jjSrf)rrBrrTrTrUrnzUserFunctionVariable.get_codecCtjSrfrrrrTrTrU python_typeqrz UserFunctionVariable.python_typecCst|jddduSN__self__)rrrrTrTrUhas_selftzUserFunctionVariable.has_selfcCrrf)rrrrTrTrU 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.rTr cell_contentsN)rrrzrrmrroot_txryrrrBrr^ co_freevarsr]rcountrr%r"r3r{r ValueErrorrZDeletedVariableZtrack_cell_existing)rQrrrrsrrrrrwrvcellrZcell_varZ closure_cellZclosure_cell_contentsZ contents_varrTrTrU bind_argszsL           zUserFunctionVariable.bind_argsrqr9rvcC&|tvr t||St||j|j|Srf)r(rGetAttrVariablerrrrQrqrvrTrTrU var_getattrs z UserFunctionVariable.var_getattrcCst|j|}tj|Srf)rrrr5r}rrTrTrUrs  z%UserFunctionVariable.call_obj_hasattrrrrrsrr3c 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|]}|qSrTr.0argrTrTrU z6UserFunctionVariable.call_function..cSi|] \}}||qSrTr)rkeyr~rTrTrU 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` regionTZnonstrict_traceable) FSDPState),rr_dynamoZpatch_dynamo_configrchangesrZDynamoConfigPatchVariabler0 RuntimeErrorZnonstrict_tracerrbindrrrzrrrbrrrZ USER_ERRORrrTorchInGraphFunctionVariablerinvoke_and_store_as_constantrZcurrent_tracerZ,unsafe_allow_externally_visible_side_effectsutilsZ8_disable_side_effect_safety_checks_for_current_subtracerrZ2allow_externally_visible_side_effects_in_subtracerrrZunder_activation_checkpointZ#allow_side_effects_under_checkpointZ/torch.distributed.fsdp._fully_shard._fsdp_stater ExceptionZ _pre_forwardZ _post_forward)rQrqrrrsZ args_constZ kwargs_constrer=Zfn_vartypmsgfn_namerrrrTrUrs         "z"UserFunctionVariable.call_functionFreNr)rbrcrdrr_nonvar_fields classmethodrrVrrrrrrrr\rr3rrrr __classcell__rTrTrrUr:sF  7 rcsFeZdZddfdd ZeddZ   dddZZS)BuiltinMethodVariableFreNc s,tjdi|t|tjsJ||_dSrW)rrVrzrBuiltinMethodTyperrrrTrUrVs zBuiltinMethodVariable.__init__cCs0|j}|j}|tur|dkpt|tuo|dkS)N__new__ __contains__)rrbrotype frozenset)obj method_self method_namerTrTrUis_supported_builtin_methods z1BuiltinMethodVariable.is_supported_builtin_methodrqr9rrrrsrr3cCs@|jj}|jj}|jot|jd}t|||}|||||Sr)rrrbrr"r3r{ call_method)rQrqrrrsrrvZ obj_sourceZobj_vtrTrTrUr%s z#BuiltinMethodVariable.call_functionrrr)rbrcrdrV staticmethodrrr rTrTrrUr s  r c 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..closeTrT) ZCALL_INTRINSIC_1throwrAr/rZ__InternalThrowException)r2r:r^allrrmr#Z push_manyr0r$rr5r9ZExceptionVariable GeneratorExitsys version_infoZnext_instructionopnamerrrZsymbolic_resultrrrrrr)rQrqrvrrrsr)retvalexc_typerrTrUrs~                  (  > z(LocalGeneratorObjectVariable.call_methodrr7r)"rbrcrdrCodeTyperrVrrrrrr__repr__r&rrrr#r2r3builtinsboolr5rpr3r%r6r9r:r0rrr rTrTrrUr2sL     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)rbrcrdrrTrTrTrUrPrsrPcsVeZdZdZeddeffddZddZdd Z    dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_clsvtc "tjdi|||_||_dSrW)rrVrSrR)rQrSrRrsrrTrUrVs z'LocalGeneratorFunctionVariable.__init__cCs&||jjvr t||St|j|Srf)r__dict__keysrrS)rQrvrTrTrU __getattr__s  z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr-)r!r.r/)rQrqrrrsr.rTrTrU_build_inline_tracers z3LocalGeneratorFunctionVariable._build_inline_tracerrqr9rrrrsrrer3cCsHt|js J||||}|j}|j}|j||||jdSr)rrSrrXrrRr)rQrqrrrsrrRrrTrTrUrs  z,LocalGeneratorFunctionVariable.call_functionr) rbrcrdrrr3rVrWrXrr rTrTrrUrQs"   rQcs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)NrR)rrVrP)rQrSrsrrTrUrVs zA z7WrappedUserMethodVariable.reconstruct..r/F add_push_nullri extend_outputrrQrrTrsrUr&@ z%WrappedUserMethodVariable.reconstructrrrbrcrdrVrr&r rTrTrrUrh- rhcrg)WrappedUserFunctionVariablereNc s2|ddtj|jfi|||_||_dS)Nr)rnrrVrrirrjrrTrUrVGs  z$WrappedUserFunctionVariable.__init__rqr9rrrrsrr3crkrfrlrnrrTrUrMroz)WrappedUserFunctionVariable.call_functioncrp)NcrqrfrrrTrsrTrUrtYruz9WrappedUserFunctionVariable.reconstruct..r/FrvryrTrsrUr&Xrzz'WrappedUserFunctionVariable.reconstructrrr{rTrTrrUr}Fs r}csTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr |S|Srf)rzrTensorVariableZget_real_valuer)xrTrTrUconvert_s z-invoke_and_store_as_constant..convertcsg|]}|qSrTrTrrrrTrUrdrz0invoke_and_store_as_constant..csi|] \}}||qSrTrTrrrrrTrUrez0invoke_and_store_as_constant..r)rrZregister_attr_or_moduler#)rqrrvrrrsresrTrrUr^srcseZdZdhejZ d$ d%fdd ZddZdd Zd d Zd d Z ddde de fddZ fddZ ddZ fddZddZddZddZd&d"d#ZZS)'rrNrec  s| ddur| jtdtjdi| t|ts Jt|tj s*Jt|t s1J||_ ||_ ||_ ||_||_||_||_||_dS)N mutation_typerrT)rhupdater1rrVrzrrrrLr\rrRrrYr[rr wrapped_fn) rQrrRrrYr[rrrrsrrTrUrVts z#NestedUserFunctionVariable.__init__cCrrfrTrrTrTrUrrz$NestedUserFunctionVariable.self_argscCs |jSrf)rRrrrTrTrUrrz#NestedUserFunctionVariable.get_codecCrrfrrrTrTrUrrz&NestedUserFunctionVariable.python_typecCs|jrtt|j|j|j}|jr|j|_ |j r%|j |_ |j rH|j }t |tr>ddlm}t||}t |tsEJ||_|S)Nrr)rrrrrRrrrrYrXr[rZrrzrorrr\r)rQrArrrTrTrUrs&      z'NestedUserFunctionVariable.get_functionrqr9name_varr~cCs|jj||j|tdSrf)rr store_attrrr5)rQrqrr~rTrTrU call_setattrsz'NestedUserFunctionVariable.call_setattrcs,|dkr |j|g|RSt||||S)N __setattr__)rrrrQrqrvrrrsrrTrUrsz&NestedUserFunctionVariable.call_methodcCs |jduSrf)rrrTrTrU has_closurerz&NestedUserFunctionVariable.has_closurecs |dkr |jSt||S)Nrb)rrr const_getattrrrrTrUrs z(NestedUserFunctionVariable.const_getattrcCrrrTrrTrTrUrrz#NestedUserFunctionVariable.has_selfcCrrfr+rrTrTrUrrz&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|]}tdVqdSrf)r.)r_rTrTrUr?z7NestedUserFunctionVariable.bind_args..)rrrrrrrYrorr_r^rr[Zkeys_as_python_constantrZrrrapply_defaultsr\ argumentsrrrrrkr) rQrrrrsrRrAr=rrwrvrrTrTrUrs(     z$NestedUserFunctionVariable.bind_argsrr7csfdd|j|jgt|jjj|j r+|j n  dg|j r=|j n  dg|j rO|j n  dg|j rzz|j }|gWqtyy|j Yqw dgtdd|jrfdd|jtddtdtddd d lm}|}|jj|r|jjj|D]\}}|td|qdSdS) Ncs tdS)Nr)load_import_fromrbrTrrTrUrt z8NestedUserFunctionVariable.reconstruct..Fc ddS)N functoolswrapsrrTrrTrUrt rr/rTrr8)rwrRrxZcreate_load_const_uncheckedrr5r}rrrYZcreate_load_constrr[rrrrrrr!r9r"rrZhas_pending_mutationZstore_attr_mutationsrZdup_topr)rQrrr9rqrvrrTrrUr&s`             z&NestedUserFunctionVariable.reconstructrfrrK)rbrcrdrrrVrrrrr3rrrrrrrr&r rTrTrrUrns6   rcrg)!WrappedNestedUserFunctionVariablereNc s|dd|dd|dd|dd|dd|dd|dd|ddt|j|j|j|j|j|j|j |j ||_ ||_ dS) NrrRrrYr[rrr) rnrrVrrRrrYr[rrrrirrjrrTrUrV"s(         z*WrappedNestedUserFunctionVariable.__init__rqr9rrrrsrr3crkrfrlrnrrTrUr8roz/WrappedNestedUserFunctionVariable.call_functioncrp)NcrqrfrrrTrsrTrUrtDruz?WrappedNestedUserFunctionVariable.reconstruct..r/FrvryrTrsrUr&Crzz-WrappedNestedUserFunctionVariable.reconstructrrr{rTrTrrUr!s rcsxeZdZddhejZddfdd ZddZed d Z     dddZ dddZ d d de fddZ Z S)SkipFunctionVariablerreasonNrec rTrW)rrVrr)rQrrrsrrTrUrVP zSkipFunctionVariable.__init__cCrrfrrrTrTrUrUrz'SkipFunctionVariable.as_python_constantcCs$t|s t|tj|||dSr)r,r!rr FUNCTION_MATCHrrTrTrUrXs z'SkipFunctionVariable.create_with_sourcerqr9rrrrsrr3c 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)6NZ_torchdynamo_disableFZ_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` callrrz%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/SourcelessBuilderrdzrczz?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. 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: )rrrrrrrZ graph_breakrhrZ skip_framerrZdont_skip_tracingbuilderrr}rzrrrgetfilermrcr warn_oncejoinr)rQrqrrrsrZgraph_break_msgZskip_frame_msgrZ rebuilt_fnqualnameZ module_or module_namepathrrZknown_python_builtin_modulesrrTrTrUras            & z"SkipFunctionVariable.call_functioncCstjt|j|Srf)rr5r}rrrrTrTrUrrz%SkipFunctionVariable.call_obj_hasattrrvcCrrf)r(rrrrrrrTrTrUrs z SkipFunctionVariable.var_getattrrfrrrqr9)rbrcrdr3rrVrrrrrrrr rTrTrrUrIs*  xrcrg)WrappedSkipFunctionVariablereNc sD|dd|ddtj|jfd|ji|||_||_dS)Nrr)rnrrVrrrirrjrrTrUrVs   z$WrappedSkipFunctionVariable.__init__rqr9rrrrsrr3crkrfrlrnrrTrUrroz)WrappedSkipFunctionVariable.call_functioncrp)NcrqrfrrrTrsrTrUrtruz9WrappedSkipFunctionVariable.reconstruct..r/FrvryrTrsrUr&rzz'WrappedSkipFunctionVariable.reconstructrrr{rTrTrrUrr|rcsReZdZdZdfdd 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". reNc rTrW)rrV wrapper_obj attr_to_trace)rQrrrsrrTrUrVrz$WrapperUserFunctionVariable.__init__rqr9csF||jkrt|j|j}|jot|j|}t|||St||Srf) rrrrr"r3r{rr)rQrqrvr~rrrTrUr s z'WrapperUserFunctionVariable.var_getattrcCrrfrTrrTrTrUrrz%WrapperUserFunctionVariable.self_argsrrrrsrr3c 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_inforcrarr/)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)rrrrsplitrrrrlogging getLogger isEnabledForDEBUGZ_guardsZTracingContext extract_stackr filenamelinenor traceback format_listrdebugrrrrZgetattr_and_tracerr5) rQrqrrrsZ target_fnrrZ dynamo_loggerZ user_stackZ frame_locZuser_stack_formattedZuser_stack_traceall_argsrTrTrUrs4       z)WrapperUserFunctionVariable.call_functionrrr) rbrcrdrrVrrrr rTrTrrUrsrcs*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. reNc s tj||fi|||_dSrfr[)rQrrZself_objrsrrTrUrVDr\z"WrapperUserMethodVariable.__init__cCr]rfr^rrTrTrUrHrz#WrapperUserMethodVariable.self_argsr)rbrcrdrrVrr rTrTrrUr=srcCstjr ddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesrrrTrTrU_traceable_collective_remapsLs  rcCs>tjs Jd|tvsJ|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rrrrvaluesrbZ import_sourcer")rqrZ inner_nameZ path_sourcerTrTrU_traceable_collectives_sourceWs   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. reNc s,tj|fi|t|tsJ||_dSrf)rrVrzrreplacement_var)rQrrrsrrTrUrVks z*CollectiveFunctionRewriteVariable.__init__rqr9cKs6t||\}}t|ft|fd|i||d|S)Nr)rr)rrewriter)rqZold_fnroptionsnew_fnZ new_sourcerTrTrUr}psz(CollectiveFunctionRewriteVariable.createcCst|o |tvSrf)r isfunctionr)variablerTrTrU can_rewritezsz-CollectiveFunctionRewriteVariable.can_rewritecCst|}|t||fSrf)rr)rqrrrTrTrUrs z)CollectiveFunctionRewriteVariable.rewriterrrrsrr3c 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_STRrTZasync_opz)async_op=True for distributed collectivesz, args= , kwargs=z3`torch.compile` doesn't support `async_op=True for ropzUnsupported all_reduce op: )Ztorch.distributedrrrrrrr\rrrrr SUPPORTABLEZ all_reduceZreduce_scatter_tensorZ_reduce_scatter_baserhrrdefaultrrr5r}rr) rQrqrrrsdistrrZ reduce_op_varZ reduce_oprTrTrUrs<      z/CollectiveFunctionRewriteVariable.call_functionrrr) rbrcrdrrVrr}rrrr rTrTrrUr`s$    rcs.eZdZ        d fd d ZZS) FunctoolsWrapsVariablerqr9rrrrsrrer3cs6|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)rzrrclonerrrrrrrTrUrs  z3FunctoolsWrapsVariable.call_function..wraps)r^rZLambdaVariablerr)rQrqrrrsrrrrUrs  z$FunctoolsWrapsVariable.call_functionr)rbrcrdrr rTrTrrUrsrc@s.eZdZddZ       dd d Zd S)CollectionsNamedTupleFunctioncCrrfrrrTrTrUrrz0CollectionsNamedTupleFunction.as_python_constantrqr9rrrrsrrer3cCslt||}|r#|jdd|Didd|D}tj|tdStdd|d|d gtjd dS) NcSrrTrrrTrTrUrrz?CollectionsNamedTupleFunction.call_function..cSrrTrrrTrTrUrrz?CollectionsNamedTupleFunction.call_function..rznamedtuple constructionzargs=rz?`torch.compile` only support certain input types for namedtupler) r&rrrZUserDefinedClassVariabler2rrr)rQrqrrrs constant_argsrrTrTrUrs$   z+CollectionsNamedTupleFunction.call_functionNr)rbrcrdrrrTrTrTrUrsrcseZdZdeddffdd ZddZd d d Zd d Z        d!ddZddde defddZ ddde fddZ ddZ ddZ ZS)"FunctoolsPartialVariablerAreNc sPtjdi|||_t|tsJ||_t|tsJ||_t t |_ dSrW) rrVrArzrprrr\keywordsrpartialr*Z fake_value)rQrArrrrsrrTrUrVsz!FunctoolsPartialVariable.__init__cCrrf)rrrrTrTrUrrz$FunctoolsPartialVariable.python_typerr7csfdd|j|jr|j|js)tt|jdddS|jt |j } t|t|jd|ddS)Ncr)NrrrrTrrTrUrtrz6FunctoolsPartialVariable.reconstruct..r/F) rwrArrforeachrrxrr^rrorVZcreate_call_function_kw)rQrrVrTrrUr&s  z$FunctoolsPartialVariable.reconstructcCrrfrrrTrTrUr rz%FunctoolsPartialVariable.get_functionrqr9rrrrsrr3cCs(|j|}i|j|}|j|||Srf)rrrrAr)rQrqrrrsZ merged_argsZ merged_kwargsrTrTrUr s z&FunctoolsPartialVariable.call_functionrvcCstjttt|Srf)rr5r}rrrr*rrTrTrUrsz)FunctoolsPartialVariable.call_obj_hasattrcCs|jot|j|}|dkr|jS|dkrtj|j|dS|dkr1dd|jD}tj||dS|t vr;t ||St t |dS)NrArrrrcSsi|] \}}t||qSrT)r5r}rrTrTrUr&sz8FunctoolsPartialVariable.var_getattr..) rr"rAr ListVariablerrrrConstDictVariabler(rrr)rQrqrvrrrTrTrUrs z$FunctoolsPartialVariable.var_getattrcC:tj|jgdd|jDRidd|jDS)NcSrrTrrrTrTrUr/rz?FunctoolsPartialVariable.as_python_constant..cSrrTrrrTrTrUr0rz?FunctoolsPartialVariable.as_python_constant..)rrrArrrrrrrTrTrUr,sz+FunctoolsPartialVariable.as_python_constantcCr)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantscSrrTguard_as_python_constant)rrrTrTrUr7rzEFunctoolsPartialVariable.guard_as_python_constant..cSrrTrrrTrTrUr8rzEFunctoolsPartialVariable.guard_as_python_constant..)rrrArrrrrrrTrTrUr3sz1FunctoolsPartialVariable.guard_as_python_constantrKr)rbrcrdr3rVrr&rrrrrrrr rTrTrrUrs0    rcseZdZdddhejZeejdee de fe j ffddZ edd Zdedd ffd d Zedefd dZddZddZ        d ddZ      d!ddZddZZS)"PolyfilledFunctionVariablerr traceable_fnre.cCrrfrT)rrTrTrU_get_polyfill_handlersDsz1PolyfilledFunctionVariable._get_polyfill_handlerscCrr)r!rr rrrTrTrUrIs z-PolyfilledFunctionVariable.create_with_sourceNc stjdi|||_|||}t|s"Jd|d|dD]}t||d}|r8t|s4J|}qAq$td|d||_||_ dS)NzPolyfill handler z is not callable for )Z__torch_dynamo_polyfill__Z__python_implementation__z# does not have a traceable functionrT) rrVrrrhcallablerrrr)rQrrshandlerZcandidate_attr candidaterrrTrUrVOs     z#PolyfilledFunctionVariable.__init__cCrrf)rrrTrTrU polyfill_fnfsz&PolyfilledFunctionVariable.polyfill_fncCr;)NZ*__torch_dynamo_can_constant_fold_through__F)rrrrTrTrUcan_constant_fold_throughjz4PolyfilledFunctionVariable.can_constant_fold_throughcCrrfrrrTrTrUrorz'PolyfilledFunctionVariable.get_functionrqr9rrrrsrr3c 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) NcSrrTrrrTrTrUr}rz.cSrrTrrrTrTrUr~rz.r/rcss@|]}t|tjrt|jtpt|tjo|tuVqdSrf)rzrr5rintSymNodeVariablerrrTrTrUr?s  z;PolyfilledFunctionVariable.call_function..rcss|]}|VqdSrfas_proxy)rarTrTrUr?rcSs$g|]}t|tjr |jn|jqSrT)rzrr5rsym_numrrTrTrUrs  )r)rr'rrr3r{rNsumr^rzrr TupleVariablerDrr}r create_proxyrZsym_sumrorr)rQrqrrrsrZtraceable_function_variablerTrTrUrrsL      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"r)rQrqrvrrrsmethodrZpolyfilled_method_variablerTrTrUrsz&PolyfilledFunctionVariable.call_methodcCrrfrrrTrTrUrrz-PolyfilledFunctionVariable.as_python_constantrrrrrsrrer3)rbrcrdr3rrrcacher\rrrrrrr<rVpropertyrrrrrrr rTrTrrUr<sD$  4 rc@seZdZddZdS)TracebackVariablecCsdSrfrTrrTrTrUrszTracebackVariable.call_functionNrbrcrdrrTrTrTrUrs rcs4eZdZfddZddZddZddZZS) SysFunctionVariablec stjdi|||_dSrW)rrVr)rQrrsrrTrUrVs zSysFunctionVariable.__init__cCs`t|jr|jd}|j}d}t|||t||g}ntdtdtdg}t|S)Nr)r^Z exn_vt_stackrJr3r{rr5r)rQrqZexnrtbrrTrTrUexc_infos     zSysFunctionVariable.exc_infocCs||jdSre)rrrrTrTrU exceptionr*zSysFunctionVariable.exceptioncCs0|jtjur ||S|jtjusJ||Srf)rrFrrrrTrTrUrs   z!SysFunctionVariable.call_function)rbrcrdrVrrrr rTrTrrUrs  r) create_tma_experimental_metadatacreate_tma_stable_metadataTMADescriptorMetadataTritonHOPifierc@seZdZdedefddZdedefddZdedefd d Z de e j j jd ffd d ZddZddZddZddZdedefddZdddeeddfddZdefddZd S)!DynamoTritonHOPifierrrecCst|rf)r)rQrrTrTrUraise_unsupportedrz&DynamoTritonHOPifier.raise_unsupportedmaybe_callablecCst|ttfSrf)rzrr)rQrrTrTrU is_callablerz DynamoTritonHOPifier.is_callabler~cCs|jSrfr)rQr~rTrTrU 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)listsrrzrrrrr)rQgridrrTrTrU check_grids    zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSi|] \}}tj||qSrTrr5r}rrTrTrUrsz2DynamoTritonHOPifier.call_grid..)rr)rQrmetarqrTrTrU call_gridszDynamoTritonHOPifier.call_gridc Cs*ddlm}|||}||||}|S)Nr/r)rrr}r) rQZuser_fnrrrsrqrrZwrapped_user_functionrrTrTrUcall_user_defined_fn s  z)DynamoTritonHOPifier.call_user_defined_fncCs*ddlm}||t|j||}|S)Nr/)VariableBuilder)rrr" kernel_source_wrap)rQZuser_objrqrrvrZwrapped_user_objrTrTrUwrap_user_defined_objs z*DynamoTritonHOPifier.wrap_user_defined_objcCs||}dd|D}|S)NcSrrTr)rrrTrTrUr rz=DynamoTritonHOPifier.maybe_unpack_configs..)Zunpack_var_sequence)rQZconfigsrqrTrTrUmaybe_unpack_configss z)DynamoTritonHOPifier.maybe_unpack_configsrcCs|s |d|S)Nz`@triton.heuristics must return constant values because configs can only contain constant values.)Zis_python_constantr r)rQrrTrTrUmaybe_unpack_heuristic_result$s z2DynamoTritonHOPifier.maybe_unpack_heuristic_resultrTritonKernelVariablerrcCs>|jdus t|dkr|dt||j|j|d|jdS)Nr/z7Triton kernels should be called with only a single gridr)kernel kernel_idxrr)rr^r rr!r"r)rQrrrrTrTrU 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)rcSrrTrrrTrTrUrSs z1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSrT)rzrrr4rTrUr`s cs i|] \}}t|s||qSrT)rzrr4rTrUres z.Unexpected argument type for a Triton kernel: rrrT)r"constant_args_idxrtma_descriptor_metadatars)rbr5ZdictsrrprVrz!TMADescriptorExperimentalVariableTMADescriptorStableVariable to_metadata get_tensorr*torch._higher_order_ops.triton_kernel_wrapr$r%rZrealizerr~rr reprZadd_constant_argsr\rrr"r)rQrZgridsZcombined_args_rawrqrr'rrZ combined_argsr$r%rZnon_constant_argsr&rrTr4rUcall_HOP@sX          zDynamoTritonHOPifier.call_HOPN)rbrcrdrr r rrOrrrorZfxproxyZProxyrrrrrrrr#r5r.rTrTrTrUr s$   r cseZdZUded<ded<eeed<ded<dfd d Z      dddZ      dfdd Zde de fddZ Z S)r r:rr;r!r"r"rreNc s4|dd|_tjdi|t||||dS)NrrT)rnrrrV dynamo_triton_hopifier_singletonZ init_variable)rQr!r"rrsrrTrUrVszTritonKernelVariable.__init__rqr9rrrrsrr3cCst||||Srf)r0Zcall_triton_kernelrrTrTrUrsz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)r0r#Zcall_runrrrrrTrUrs  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nr/r4)r)rbr5tensorrrzr}Z evaluate_expr)rQrr5rrTrTrUspecialize_symbolics   z(TritonKernelVariable.specialize_symbolicrrr) rbrcrdrrrrVrrrr4r rTrTrrUr s.    r csHeZdZ        dfdd Zd d ZdddZddZZS)r(data_ptrvariables.DataPtrVariabledimslist[ConstantVariable] block_dims element_sizer5c s>t|tjsJtjdi|||_||_||_||_dSrW) rzrDataPtrVariablerrVr5r7r9r:)rQr5r7r9r:rsrrTrUrVs  z*TMADescriptorExperimentalVariable.__init__cCs*tdd|jDdd|jD|jS)NcSrrTrrdimrTrTrUrrzATMADescriptorExperimentalVariable.to_metadata..cSrrTrr<rTrTrUrr)rr7r9r:rrrTrTrUr*s z-TMADescriptorExperimentalVariable.to_metadatarr7csXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorZcreate_Zd_tma_descriptor)rr^r7rTrsrTrUrtsz?TMADescriptorExperimentalVariable.reconstruct..r/F) rwr5r&r7r9r:rrr^)rQrrrrTrsrUr&s   z-TMADescriptorExperimentalVariable.reconstructcCrrf)r5 from_tensorrrTrTrUr+rz,TMADescriptorExperimentalVariable.get_tensor)r5r6r7r8r9r8r:r5rKrbrcrdrVr*r&r+r rTrTrrUr(s  r(csBeZdZ    dfdd ZddZdd d ZdddZZS)r)r3variables.TensorVariable block_shapevariables.ListVariablec s2t|tjsJtjdi|||_||_dSrW)rzrr~rrVr3rA)rQr3rArsrrTrUrVs z$TMADescriptorStableVariable.__init__cCst|jSrf)r rArrrTrTrUr*rz'TMADescriptorStableVariable.to_metadatarr7cs@fddd|j|jddS)Ncr)Nztriton.tools.tensor_descriptorZTensorDescriptorrrTrrTrUrtsz9TMADescriptorStableVariable.reconstruct..r>r)rwZ load_methodr3r&rArryrTrrUr&s    z'TMADescriptorStableVariable.reconstructrecCrrf)r3rrTrTrUr+rz&TMADescriptorStableVariable.get_tensor)r3r@rArBrK)rer@r?rTrTrrUr)s  r)cs@eZdZdeddffdd Z     dd dZZS)'CreateTMADescriptorExperimentalVariablerankreNc s(|dvsJtjdi|||_dS)N)r/rrT)rrVrD)rQrDrsrrTrUrV s  z0CreateTMADescriptorExperimentalVariable.__init__rqr9rrrrsrr3cCs.d|vr|dn|d}t|tjstd|jd|jdkrGt|t|dks,Jd|vr4|dn|dg}d|vrA|dn|d g}nr=Z block_dimrZdim1Zdim0Z block_dim1rAZ block_dim0r:r)r5r7r9r:)rzrr;rrDr^r()rQrqrrrsrEr7r9r:rTrTrUr s6  z5CreateTMADescriptorExperimentalVariable.call_functionr)rbrcrdrrVrr rTrTrrUrCs rCc@s&eZdZ        d d d Zd S) !CreateTMADescriptorStableVariablerqr9rrrrsrrer3cCs<d|vr|dn|d}d|vr|dn|d}t||dS)Nr3rrAr/)r3rA)r))rQrqrrrsr3rArTrTrUr5 s z/CreateTMADescriptorStableVariable.call_functionNrrrTrTrTrUrG4 srGrfr)rrNrrrrrFrrcollections.abcrrtypingrrrrr Ztyping_extensionsr Z unittest.mockr weakrefr rZtorch._dynamo.excr rarrrrZbytecode_transformationrrrr8rrrrrrrrrrZguardsr r!rr"r#r$r%rr&r'r(r)r*r+r,r-r.baser0r1r2r3rbr5Z#torch.distributed.fsdp._fully_shardr6ModuleNotFoundErrorZtorch._dynamo.codegenr7r!r9r,r:r;r<rMrOrgr@rjryrlrr\rrrrrrrr rrPrQrYrZrhr}rrrrrrrrrrrrrrrrrr r r r r0r r(r)rCrGrTrTrTrUs      0 ,      5  "[ B 7Y 4(A  TQ!.'!5