o )vi\'@sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZddlmZddlmZddlZddlmZmZmZdd lmZmZmZdd lmZmZmZm 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)graph_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)typestrValueMutationNewVariableTrackerConstantVariable)_fsdp_param_group)InstructionTranslator)TritonGridTypeTritonKernelType_F)boundtxr1cCs,t|tr|S|st||Stj||SN) isinstancer-buildr LazyVariableTrackercreate)r6valsourcer>^/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torch/_dynamo/variables/functions.pywrap_bound_argWs  r@cCs6t|D]\}}t|ttfrt||||<qdSr7)listitemsr8tupledictr@)r6resultkvr>r>r?wrap_args_kwargscs 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_cellvarsjs  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?r`s  z%UserFunctionVariable.call_obj_hasattrr{r|r}r~r-c s|jtjjurft|jj|i|}|jd}t|t s>| }d|j d}t dd|j d|d|d|gtjdt|ts\|}d |d }t d ||d |d dgd|j} tj| ddS|jrtt||j|||S|jjjr|jjjszddlm} Wn tyd} Ynw| dur|j| j| jfvrtjj|t !|||WdS1swYt !|||S)Nrz=`nonstrict_trace` expects a callable, but got value of type <>zTypeError from user codezcall_function(, )gb_typecontext explanationhintsz(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)"rlr_dynamononstrict_tracergrrr{r8rorrrrr USER_ERRORrrzr 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_vartypmsgfn_namerlrrr>r?rfs`         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}r rQ obj_sourceobj_vtr>r>r?rs z#BuiltinMethodVariable.call_functionrrr)rrrr staticmethodr rrr>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[rr}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(r)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?r$s   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.rbuild_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)N unimplemented inline_call)r_is_generator_exhaustedr StopIterationr rDr$ inline_call_rrrrr eval_frame skip_coderrr)rur6r)er>r>r? next_variables*    . z*LocalGeneratorObjectVariable.next_variablecCrrr>rr>r>r?has_unpack_var_sequencerz4LocalGeneratorObjectVariable.has_unpack_var_sequencercCrNTr>rr>r>r?has_force_unpack_var_sequence"rz:LocalGeneratorObjectVariable.has_force_unpack_var_sequencecCs:g} z |||Wntyt|Y|Swqr7)appendr8rr)rur6rEr>r>r?r!%s z6LocalGeneratorObjectVariable.force_unpack_var_sequencec CsL||}z||WdSty%}z ||WYd}~dSd}~wwr7)r_raise_exception_variablerexception_handler)rur6excr)r7r>r>r?_setup_exception/s z-LocalGeneratorObjectVariable._setup_exceptioncCs|jdup |jjdkS)Nr)rinstruction_pointerrtr>r>r?_is_generator_just_started8sz7LocalGeneratorObjectVariable._is_generator_just_startedcCt|jddS)Nr F)rkrrtr>r>r?r2;sz4LocalGeneratorObjectVariable._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? Qs  z;LocalGeneratorObjectVariable.call_method..closeTr>) CALL_INTRINSIC_1throwrJr*r__InternalThrowException)r8rBrallr TypeErrorr push_manyr2r r r/r@ExceptionVariable GeneratorExitsys version_infonext_instructionopnamer RuntimeErrorrsymbolic_resultrrrrrr)rur6rQr{r}r)retvalexc_typerr>r?r>sz                   (  > z(LocalGeneratorObjectVariable.call_method)!rrrrWCodeTyperrrrrvrzrrr__repr__r$rrrrr8r9builtinsboolr;rAr-r!r@rBr2rrrr>r>rr?rsJ    rc@seZdZdZdS)4ContextlibContextManagerLocalGeneratorObjectVariablez .. note:: This is only used when the function is annotated with @contextlib.contextmanager It is a special case of a generator function as we do not allow return a context manager from a torch.compile function. N)rrrrbr>r>r>r?r`sr`csVeZdZdZeddeffddZddZdd Z    dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_clsvtc "tjdi|||_||_dSr)rrrcrb)rurcrbr}rr>r?rs z'LocalGeneratorFunctionVariable.__init__cCs&||jjvr t||St|j|Sr7)r__dict__keysrkrc)rurQr>r>r? __getattr__s  z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr-)rr.r/)rur6r{r}r.r>r>r?_build_inline_tracer s z3LocalGeneratorFunctionVariable._build_inline_tracerr6r1r{r|r}r~rr-cCsHt|js J||||}|j}|j}|j||||jdSr)rrcrrrhrrbr=)rur6r{r}rrPr[r>r>r?r*s  z,LocalGeneratorFunctionVariable.call_functionr) rrrrbrr-rrgrhrrr>r>rr?ras"   racs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)Nrb)rrr`)rurcr}rr>r?rHs zr?rhOszHFunctionDecoratedByContextlibContextManagerVariable._build_inline_tracer)rrrrbrrhrr>r>rr?ri?s ricseZdZdZdfdd 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 )rurlr r}rr>r?r`s zUserMethodVariable.__init__cCs|jjd|jd|jdS)Nrrr)rrrlr rtr>r>r?r]dszUserMethodVariable.__repr__cCs|jgSr7)r rtr>r>r?rgrzUserMethodVariable.self_argscCrr7)rW MethodTypertr>r>r?rjrzUserMethodVariable.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_rulesrorlrr rrrIis_root_tracerr8r NNModuleVariablerk startswithrrrr0FSDPParamGroupuse_training_stateTorchCtxManagerClassVariablerrrzr) rur6r{r}ro call_argsvar module_attrrlrr>r?rms<    z UserMethodVariable.call_functioncstddSNr*)rrrtrr>r?rrz*UserMethodVariable.inspect_parameter_namesrQcsF|jot|j|}|dkr|jS|dkrt||j|St||S)Nr__func__)r=rr r-r9rlrr)rur6rQr=rr>r?rs zUserMethodVariable.var_getattrrr) rrrrbrrr]rrrrrrr>r>rr?rm]s" =rmc<eZdZdfdd Z      dfd d ZZS)WrappedUserMethodVariablerNc sB|dd|ddtj|j|jfi|||_||_dSNrlr )rNrrrlr wrappedrrurrr}rr>r?rs   z"WrappedUserMethodVariable.__init__r6r1r{r|r}r~r-c,|j|t|||}|j||Sr7renterrrexitrur6r{r}rErr>r?r  z'WrappedUserMethodVariable.call_functionrrrrrrrrr>r>rr?rrcr~)WrappedUserFunctionVariablerNc s>|dd|ddtj|jfi|||_||_dSr)rNrrrlrrrrr>r?rs   z$WrappedUserFunctionVariable.__init__r6r1r{r|r}r~r-crr7rrrr>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)rrr8rrrWr\rDrrPr[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?rrz&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_closure0rwz&NestedUserFunctionVariable.has_closurecCrrr>rtr>r>r?r3rz#NestedUserFunctionVariable.has_selfcCrr7r+rtr>r>r?r6rz&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?rH@z7NestedUserFunctionVariable.bind_args..)rrrWrTr[rrr\rCrBrangerrr^keys_as_python_constantrXrgrrrrDrrHrIrrSrr]) rurOr{r}rPr`r5rErrQrr>r>r?r9s(     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>r%r>r?S z8NestedUserFunctionVariable.reconstruct..Fc ddS)Nrwrapsrr>rr>r?rwrr*r T) add_push_nullrP extend_outputcreate_load_const_uncheckedr[r/r;rryr\create_load_constr]r^r_rrrrr)rur%r_r>rr?r$QsF          z&NestedUserFunctionVariable.reconstructr7r)rrrrorrrrrrrrrrrr$rr>r>rr?rs$ rcsxeZdZddhejZddfdd ZddZed d Z     dddZ dddZ d d de fddZ Z S)SkipFunctionVariablerreasonNrc rdr)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 |jdd}t |jdd}|durWdnt|}z)t |j}d|d|d} d|dg} d|vr| d|d|ddg7} Wn^t yddh} || vrd|d |d} d!d"g} n?|dur| d#rd$|d |d } d%g} tjj| d&d&| nd'|d |d(} d)d*g} tjj| d&d&| Ynw|d+krd,} g} |jr|jnd-} td.d/|d0|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` 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.rzrzz?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_breakgetrrkgetfilerPruutils warn_oncejoinr) rur6r{r}graph_break_msgqualname module_or module_namepathrrknown_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?rs*  hrcsJeZdZdZdfdd 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 rdr)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?r srcCstjr 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_source6s   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?rJs z*CollectiveFunctionRewriteVariable.__init__r6r1cKs6t||\}}t|ft|fd|i||d|S)Nr=)rr=)rrewriter)r6old_fnr=optionsnew_fn new_sourcer>r>r?r;Osz(CollectiveFunctionRewriteVariable.createcCst|o |tvSr7)rg isfunctionr)variabler>r>r? can_rewriteYsz-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|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_STRr>async_opz)async_op=True for distributed collectivesz, args= , kwargs=z3`torch.compile` doesn't support `async_op=True for ropzUnsupported all_reduce op: )torch.distributedrrrrgrrlrDrrrrr SUPPORTABLE all_reducereduce_scatter_tensor_reduce_scatter_baserrrdefaultrr r/r;rr) rur6r{r}distrr reduce_op_var reduce_opr>r>r?rds<      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*cs8t|tjr|jddStd|dgtjddS)Nr)rzfunctools.wrapsz]`torch.compile` can't trace `functools.wraps` on functions defined outside the compile regionr)r8r rclonerr rrr{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-cCslt||}|r#|jdd|Didd|D}tj|tdStdd|d|d gtjd dS) NcSg|]}|qSr>rrr>r>r?rrz?CollectionsNamedTupleFunction.call_function..cSi|] \}}||qSr>rrr>r>r?rrz?CollectionsNamedTupleFunction.call_function..) mutation_typeznamedtuple constructionzargs=rz?`torch.compile` only support certain input types for namedtupler) r!rlrBr UserDefinedClassVariabler,rr 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{foreachrrrrrrCrfcreate_call_function_kw)rur%rfr>rr?r$s  z$FunctoolsPartialVariable.reconstructcCrr7rrtr>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>rrGr>r>r?r rz?FunctoolsPartialVariable.as_python_constant..cSrr>rrr>r>r?r rz?FunctoolsPartialVariable.as_python_constant..)rrr`rr{rrBrtr>r>r?r sz+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-rrr$rrrrrrrrr>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?r&s 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>) rrrlrrcallablerkrXrr)rurlr}handlercandidate_attr candidaterrr>r?r,s     z#PolyfilledFunctionVariable.__init__cCrr7)rrtr>r>r? polyfill_fnCsz&PolyfilledFunctionVariable.polyfill_fncCrC)N*__torch_dynamo_can_constant_fold_through__F)rkrrtr>r>r?can_constant_fold_throughGz4PolyfilledFunctionVariable.can_constant_fold_throughcCrr7rrtr>r>r?rLrz'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?rZrz.cSrr>rrr>r>r?r[rz.r*rcss@|]}t|tjrt|jtpt|tjo|tuVqdSr7)r8r r/rintSymNodeVariablerrr>r>r?rHfs  z;PolyfilledFunctionVariable.call_function..rcss|]}|VqdSr7as_proxy)rar>r>r?rHqrcSs$g|]}t|tjr |jn|jqSr>)r8r r/rsym_numrr>r>r?rus  )r)r r"rlrBr-r9r^sumrr8r r TupleVariablerOr r;rI create_proxyrsym_sumrCrr)rur6r{r}rEtraceable_function_variabler>r>r?rOsH      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?rsz&PolyfilledFunctionVariable.call_methodcCrr7rrtr>r>r?rrz-PolyfilledFunctionVariable.as_python_constantrr{r|r}r~rr-)rrrr-rrr lru_cacherDrrrWrTrrr4rpropertyrr rrrrrr>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_stackr[r-r9r r/r)rur6exnrtbrBr>r>r?exc_infos     zSysFunctionVariable.exc_infocCs||jdSr|)r"rBrr>r>r? exceptionr*zSysFunctionVariable.exceptioncCs0|jtjur ||S|jtjusJ||Sr7)rrTr"r#rr>r>r?rs   z!SysFunctionVariable.call_function)rrrrr"r#rrr>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_callabler z DynamoTritonHOPifier.is_callabler<cCs|jSr7r)rur<r>r>r? 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)listsr+r8rrrr r)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)builderr3r;r) ruuser_fnr{r}r6rr3wrapped_user_functionrEr>r>r?call_user_defined_fns  z)DynamoTritonHOPifier.call_user_defined_fncCs*ddlm}||t|j||}|S)Nr*)VariableBuilder)r4r8r kernel_source_wrap)ruuser_objr6rrQr8wrapped_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-r9)r-rr'rrErFr=)rurr{r>r>r? call_getitem sz!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>r0rr>r>r?r+s z1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSr>)r8rrr.r>r?r8s cs i|] \}}t|s||qSr>)r8rr.r>r?r=s z.Unexpected argument type for a Triton kernel: rrr>)rFconstant_args_idxr-tma_descriptor_metadatar})rqr/dictsrrArfr8TMADescriptorVariable to_metadatadata_ptr from_tensorrB*torch._higher_order_ops.triton_kernel_wraprHrIrrealizer rr r'repradd_constant_argsrDrIrrFr)rurgridscombined_args_rawr6rrKrFrG combined_argsrHrIrnon_constant_argsrJr1r>r.r?call_HOPsT           zDynamoTritonHOPifier.call_HOPN)rrrrrr'rr_r)r*rCrfxproxyProxyr.r2r7r=rArCrrGr/rYr>r>r>r?r&s$   r&cseZdZUded<ded<eeed<ded<dfd d Z      dddZ      dfdd Zde de fddZ Z S)rDr2r-r3rErFrr9rNc s4|dd|_tjdi|t||||dS)Nr9r>)rNr9rr dynamo_triton_hopifier_singleton init_variable)rurErFr-r}rr>r?rgszTritonKernelVariable.__init__r6r1r{r|r}r~r-cCst||||Sr7)r]call_triton_kernelrr>r>r?rlsz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)r]rGcall_runrr)rur6rQr{r}rr>r?rvs  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nr*r.)r )rqr/tensorr r8r; evaluate_expr)rurr/r r>r>r?specialize_symbolics   z(TritonKernelVariable.specialize_symbolicrrr) rrrrZrr rrrrrerr>r>rr?rDas.    rDcs>eZdZ        dfdd Zd d Zd d ZZS)rMrOvariables.DataPtrVariabledimslist[ConstantVariable] block_dims element_sizer/c s>t|tjsJtjdi|||_||_||_||_dSr) r8r DataPtrVariablerrrOrgrirj)rurOrgrirjr}rr>r?rs  zTMADescriptorVariable.__init__cCs(dd|jDdd|jD|jfS)NcSrr>r rdimr>r>r?rrz5TMADescriptorVariable.to_metadata..cSrr>r rlr>r>r?rr)rgrirjrrtr>r>r?rNsz!TMADescriptorVariable.to_metadatacsXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorcreate_d_tma_descriptor)rrrgr>r%rur>r?rsz3TMADescriptorVariable.reconstruct..r*F) rrOr$rgrirjrrr)rur%r{r>rpr?r$s   z!TMADescriptorVariable.reconstruct)rOrfrgrhrirhrjr/)rrrrrNr$rr>r>rr?rMsrMcs@eZdZdeddffdd Z     dd dZZS)CreateTMADescriptorVariablerankrNc s(|dvsJtjdi|||_dS)N)r*r r>)rrrr)rurrr}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)rrrr rrrr>r>rr?rqs rqr7r)nrbr^rrgrYrTrWcollections.abcrtypingrrrrrtyping_extensionsr unittest.mockr rrpr r r bytecode_transformationrrrr?rrrrrrrrrrguardsrrr=rrrr rr!r"r#r$r%r&r'r(r)baser+r,r-rqr/#torch.distributed.fsdp._fully_shardr0ModuleNotFoundErrorrr1rQr2r3r4r@rHrDrrSrarjrnrorrrr`rarirmrrrrrrrrrrrrrrrr$r%r&r]rDrMrqr>r>r>r?s   0 ,       "U > 7Y  "  TO!.$