a h'[@s~dZddlZddlZddlZddlZddlZddlZddlZddlZddl 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@ddlAmBZBmCZCmDZDmEZEddlFmGZGzddlHmIZIWneJydZIYn0erddlKmLZLddlMmNZNddlOmPZPmQZQededZRdZSdZTeZUGdddZVe eVddd ZWd!d"ZXdrd#d$d%d&ZYd#d$d'd(ZZe[e\eEfd)d*d+Z]d,d-Z^hd.Z_d/d0Z`Gd1d2d2eEZaGd3d4d4eaZbGd5d6d6eaZcGd7d8d8eEZdGd9d:d:edZeGd;d<dd>efZgGd?d@d@ebZhGdAdBdBehZiGdCdDdDebZjd#d$dEdFZkGdGdHdHeaZlGdIdJdJelZmGdKdLdLeEZnGdMdNdNenZoGdOdPdPeEZpGdQdRdRepZqdSdTZrd#d$dUdVZsGdWdXdXebZtGdYdZdZebZuGd[d\d\ebZvGd]d^d^eEZwGd_d`d`eEZxGdadbdbeEZyGdcddddeEZzddelOm{Z{m|Z|m}Z}m~Z~Gdfdgdge~ZeZGdhdidieEZGdjdkdkeEZGdldmdmeEZGdndodoeEZGdpdqdqeEZdS)sa 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(eZdZedddZedddZdS) FunctionSpec)funccCs|j}|j}|j|_|j|_|j|_|d|j|_||j|j|_ |j|j |_ ||j|j|j|_ |j|j}|j t @r||nd|_||jrdnd7}|j t@r||nd|_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)selfrAcodeZvnoffrTO/var/www/auris/lib/python3.9/site-packages/torch/_dynamo/variables/functions.py__init__is zFunctionSpec.__init__cCsH|jpd|_|jpi|_tt|jt|j dtt|j|_ dS)NrT) __defaults__defaults__kwdefaults__ kwdefaultsdictziprJlenrangepos_default_map)rQrArTrTrUupdate_defaults{s   $zFunctionSpec.update_defaultsN)__name__ __module__ __qualname__rrVr`rTrTrTrUr@hsr@rAreturncCs&t|}|dur"t|}|t|<|SN) _spec_cachegetr@)rAspecrTrTrU _get_specs  rjcCst|}||i}t|}t|jD]\}} |t|krPt||||| <q(| |vr| |jvrpt| dt|| | || <q(| |j vr|j | } d} |rt || } t||j | | || <q(td| q(|t|jd} |j rt|t| ||j <n$| r(tdt|dt|j|jD]p} | |vrRt|| | || <nJ| |jvrd} |rvt || dd} t||j| | || <ntd| q.|jrt||||j<n|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: )rjr`r[ enumeraterJr]wrap_bound_argrI TypeErrorpopr_r$rXrNtuplerKrZrPlist)rAtxZ fn_sourceargskwargsribaZrem_kwinameidxZdefault_sourceextraZkwdefault_sourcerTrTrUbind_args_cachedsN         ryr9rqcCs0t|tr|S|st||Stj||SdSrf) isinstancer3buildrLazyVariableTrackercreate)rqvalsourcerTrTrUrls   rlcCs6t|D]$\}}t|ttfr t||||<q dSrf)rpitemsr{ror[rl)rqresultkvrTrTrUwrap_args_kwargssr)rcCsB|jj}|jD].}|}||vr4|||||||<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|trDddlm} t| |}|dusZt|tsZJ||_|S)Nrrpairwise) typesrrYr{ro itertoolsrr[__annotations__) rR f_globalsrvrXclosurerZ annotationsrrArrTrTrU_create_nested_fns    r> __closure__rWrB __globals____doc__rYrcCsl|o t||}zt||}Wnty:tt|Yn0|tvrNt||}|r`tj ||St ||Srf) r"inspectgetattr_staticAttributeErrorrfn_known_dunder_attrsgetattrrr}r~r3r|)rqfnrrvZsubobjrTrTrUfn_var_getattrs  rc@sReZdZddZddZddddd d d Zdeed d dZddZ ddZ dS)BaseUserFunctionVariablecCs |jSrfget_code co_filenamerQrTrTrU get_filenamesz%BaseUserFunctionVariable.get_filenamecCs |jSrfrco_namerrTrTrUget_namesz!BaseUserFunctionVariable.get_namer9list[VariableTracker]dict[str, VariableTracker]r3rqrrrsrecCs||g|||Srf)Zinline_user_function_return self_argsrQrqrrrsrTrTrU call_functionsz&BaseUserFunctionVariable.call_functionrqrvrecCsLd}zt||}Wn(ty>|dkr:t|tr:d}Yn0tj|S)NFraT)hasattr get_functionNotImplementedErrorr{NestedUserFunctionVariablerr5r~rQrqrvrrTrTrUcall_obj_hasattr's  z)BaseUserFunctionVariable.call_obj_hasattrcCstt|jSrf)rpr signaturer parametersrrTrTrUinspect_parameter_names3sz0BaseUserFunctionVariable.inspect_parameter_namescCsiSrfrTrQrqrTrTrU closure_vars6sz%BaseUserFunctionVariable.closure_varsN) rarbrcrrrstrr3rrrrTrTrTrUrs  rcseZdZdZddhejZeddZd(ddfd d Zfd d Z d dZ ddZ ddZ ddZ ddZddZeeefdddZdedddZdeedd d!Zdd"d#d$d%fd&d' ZZS))UserFunctionVariablez-Some unsupported user-defined global functionr is_constantcCst|tj|||dSNr)r! make_guardr Z CLOSURE_MATCHclsvaluerrTrTrUcreate_with_sourceCsz'UserFunctionVariable.create_with_sourceFNrec srtjfi|t|ddr&d|_nd|_t|tjtjj fsZt 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_inline)superrVrrr{rrtorchZjitZScriptFunctionrrZINFERENCE_MODErrrrQrrrs __class__rTrUrVHs   zUserFunctionVariable.__init__cst|tr|jStSrf)r-rrras_python_constantrrrTrUrbs z'UserFunctionVariable.as_python_constantcCsgSrfrTrrTrTrUrhszUserFunctionVariable.self_argscCs|jSrfrrrTrTrUrksz!UserFunctionVariable.get_functioncCs|jjSrf)rrBrrTrTrUrnszUserFunctionVariable.get_codecCstjSrfrrrrTrTrU python_typeqsz UserFunctionVariable.python_typecCst|jddduSN__self__)rrrrTrTrUhas_selftszUserFunctionVariable.has_selfcCs|jjSrf)rrrrTrTrU get_globalswsz UserFunctionVariable.get_globalsc CsZ|jr J|j}t|ts"td|jj}t|||j||}t |||j |jj pTd}t |t |jj j kspJtt|jj j |D]\}} } |jj} | | vr| | } n|jrtt|jd|} t| d}zt|| j|}Wntyt}Yn0| | | |} n>zt|| j}Wnty<t}Yn0| d| |} | || <q|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)rrr{rrmrroot_txryrrrBrr] co_freevarsr\rcountrr%r"r3r|r ValueErrorrZDeletedVariableZtrack_cell_existing)rQrrrrsrrrrrwrvcellrZcell_varZ closure_cellZclosure_cell_contentsZ contents_varrTrTrU bind_argszsH        zUserFunctionVariable.bind_argsr9rqrvcCs&|tvrt||St||j|j|Srf)r(rGetAttrVariablerrrrQrqrvrTrTrU var_getattrs z UserFunctionVariable.var_getattrrcCst|j|}tj|Srf)rrrr5r~rrTrTrUrs z%UserFunctionVariable.call_obj_hasattrrrr3rc s|jtjjurz@dd|D}dd|D}tjj|i|j}t|WSty}z"t d|d||WYd}~n d}~00|jtjj ur\t |jj |i|}|jd} t| ts | } d| jd } td d |jd |d |d | gtjdt| tsH| } d| d} td|| d| ddgd| j} tj| ddS|jrzt||j|||S|jjjs|jtjjj urtjj!"| t#$|||WdS1s0Y|jjj%rx|jjj&sxzddl'm(}Wnt)yd}Yn0|durx|j|j*|j+fvrxtjj!&| t#$|||WdS1sn0Yt#$|||S)NcSsg|] }|qSrTr.0argrTrTrU z6UserFunctionVariable.call_function..cSsi|]\}}||qSrTr)rkeyrrTrTrU 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_tracerrbindrrr{rrrarrrZ 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       0 0z"UserFunctionVariable.call_function)F)rarbrcrr_nonvar_fields classmethodrrVrrrrrrrr[rr3rrrr __classcell__rTrTrrUr:s4  7 rcsDeZdZdddfdd ZeddZdd d d d d dZZS)BuiltinMethodVariableFNrc s,tjfi|t|tjs"J||_dSrf)rrVr{rBuiltinMethodTyperrrrTrUrVszBuiltinMethodVariable.__init__cCs0|j}|j}|tur|dkp.t|tuo.|dkS)N__new__ __contains__)rrarotype frozenset)obj method_self method_namerTrTrUis_supported_builtin_methods z1BuiltinMethodVariable.is_supported_builtin_methodr9rrr3rcCs@|jj}|jj}|jo t|jd}t|||}|||||Sr)rrrarr"r3r| call_method)rQrqrrrsrrvZ obj_sourceZobj_vtrTrTrUr%s z#BuiltinMethodVariable.call_function)F)rarbrcrV staticmethodrrrrTrTrrUrs rcseZdZejeddfdd ZddZddZd d Z d d Z d dZ ddZddZ e Z ddddZddZddZddZddZdd Zd!d"Zejd#d$d%Zeed#d&d'Zd(d#d)d*Zd+d,Zd-d.Zd/d0Zded1d2d3d4fd5d6 Z Z!S)7LocalGeneratorObjectVariabler9)rR inline_tracerc s(tjfi|||_||_||_dSrf)rrVrRrr )rQrRrr rsrrTrUrV3sz%LocalGeneratorObjectVariable.__init__cCs|jSrf)rRrrTrTrUr?sz%LocalGeneratorObjectVariable.get_codecCs |jSrfrrrTrTrUrBsz)LocalGeneratorObjectVariable.get_filenamecCs |jSrfrrrTrTrUrEsz%LocalGeneratorObjectVariable.get_namecCstdSrf)rrrTrTrUrHsz)LocalGeneratorObjectVariable.get_functioncCsdSNFrTrrTrTrUrKsz%LocalGeneratorObjectVariable.has_selfcCs|Srf)rrrTrTrUraNsz%LocalGeneratorObjectVariable.__name__cCs|jjd|dS)N(r)rrarrrTrTrU__str__Qsz$LocalGeneratorObjectVariable.__str__r7codegenc Csddlm}ddlm}m}m}|}||}||}||} ||b| >||} | jsn| ||_ t |j  |Wdn1s0YWdn1s0YWdn1s0YdS)Nr)"disallow_side_effects_in_generator)r9 save_and_restart_speculation_log(temporarely_allow_writes_to_output_graph)Ztorch._dynamo.side_effectsrtorch._dynamo.symbolic_convertr9rr current_tx_get_inline_tracergenerator_exhaustedforce_unpack_var_sequenceZremaining_itemsrZListIteratorVariable reconstruct) rQrrr9rrrqsaveZdisallowtemptracerrTrTrUrVs   z(LocalGeneratorObjectVariable.reconstructcCs|j|||Srf)rrrrTrTrUrisz&LocalGeneratorObjectVariable.bind_argscCs|jSrfrrrTrTrUrlsz(LocalGeneratorObjectVariable.get_globalscCstjSrf)r GeneratorTyperrTrTrUrosz(LocalGeneratorObjectVariable.python_typecCs.ddlm}|jdur(|||gi|_|jSNr)InliningInstructionTranslator)rrr build_inline_tracer)rQrqrrTrTrUrrs   z/LocalGeneratorObjectVariable._get_inline_tracerc Cs$||}|rtt|zzXttdtdi0|WdWWtdtdO<S1sj0YWnzty}zd|_ |WYd}~nVd}~0t yYn<t y}z$t j j|t|WYd}~n d}~00WtdtdO<ntdtdO<0dS)NZ unimplementedZ inline_callT)r_is_generator_exhaustedr StopIterationr r[r)Z inline_call_rrrrrrZ eval_frameZ skip_coderr)rQrqrrrTrTrU next_variable{s"    z*LocalGeneratorObjectVariable.next_variablecCsdSr rTrrTrTrUhas_unpack_var_sequencesz4LocalGeneratorObjectVariable.has_unpack_var_sequencercCsdSNTrTrrTrTrUhas_force_unpack_var_sequencesz:LocalGeneratorObjectVariable.has_force_unpack_var_sequencecCsg}|||j|Srf)force_apply_to_var_sequenceappend)rQrqrrTrTrUrsz6LocalGeneratorObjectVariable.force_unpack_var_sequenceNcCs8z|||Wqty0t|Yq4Yq0qdSrf)r"rr)rQrqrrTrTrUr&s  z8LocalGeneratorObjectVariable.force_apply_to_var_sequencec CsL||}z||Wn.tyF}z||WYd}~n d}~00dSrf)rZ_raise_exception_variablerZexception_handler)rQrqexcrrrTrTrU_setup_exceptions  z-LocalGeneratorObjectVariable._setup_exceptioncCs|jdup|jjdkS)Nr)r Zinstruction_pointerrrTrTrU_is_generator_just_startedsz7LocalGeneratorObjectVariable._is_generator_just_startedcCst|jddS)NrF)rr rrTrTrUr sz4LocalGeneratorObjectVariable._is_generator_exhaustedrrr3)rqrvrrrsrec sB|dkr||S|dkr|S|dkrp|rRt|rRtdd|DsRtt|||}||||S|dkrt||}|s|rd|_ t dSz@| |t tdtjd kr|jjd krd|_ t dWSWn$tyd|_ t dYS0z||r"tt|WnLtyHd|_ t dYStyp|jdusfJ|jYS0n|d kr,||}z*| |t|d kr|d n|dWntyYn0||}tdtfi}z"| |t |d||Wnt|yYn 0tt||St||||dS)N__next____iter__sendcss"|]}t|to|jduVqdSrf)r{r5rrrTrTrU sz;LocalGeneratorObjectVariable.call_method..closeTrT) ZCALL_INTRINSIC_1throwr0r/rZ__InternalThrowException)r"r*r]allrrmrZ push_manyr rrr5r)ZExceptionVariable GeneratorExitsys version_infoZnext_instructionopnamerrrZsymbolic_resultrrrrrr)rQrqrvrrrsrretvalexc_typerrTrUrsp             * > z(LocalGeneratorObjectVariable.call_method)"rarbrcrCodeTyperrVrrrrrr __repr__rrrrrr"r#builtinsboolr%rpr3rr&r)r*r rrrrTrTrrUr2s<   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)rarbrcrrTrTrTrUr>rsr>csPeZdZdZededfddZddZdd Zd d d d dddZ Z S)LocalGeneratorFunctionVariablezxfunctions that behaves like iterators .. note:: This is a wrapper around (Nested)UserFunctionVariable ) generator_cls)vtc s"tjfi|||_||_dSrf)rrVrAr@)rQrAr@rsrrTrUrVsz'LocalGeneratorFunctionVariable.__init__cCs&||jjvrt||St|j|Srf)r__dict__keysrrA)rQrvrTrTrU __getattr__s z*LocalGeneratorFunctionVariable.__getattr__cCsddlm}|||||Sr)rrr)rQrqrrrsrrTrTrU_build_inline_tracers z3LocalGeneratorFunctionVariable._build_inline_tracerr9rrr3rcCsHt|jsJ||||}|j}|j}|j||||jdSr)rrArrErr@r)rQrqrrrsr rRrrTrTrUrs  z,LocalGeneratorFunctionVariable.call_function) rarbrcrrr3rVrDrErrrTrTrrUr?s   r?cs,eZdZdZfddZfddZZS)3FunctionDecoratedByContextlibContextManagerVariablezm .. note:: This is only used when the function is annotated with @contextlib.contextmanager c stj|fdti|dS)Nr@)rrVr>)rQrArsrrTrUrVszArz7WrappedUserMethodVariable.reconstruct..r/F add_push_nullrT extend_outputrrQrrTrZrUr@s z%WrappedUserMethodVariable.reconstructrarbrcrVrrrrTrTrrUrS-s  rScsBeZdZddfdd Zddddd fd d Zd d ZZS)WrappedUserFunctionVariableNrc s2|ddtj|jfi|||_||_dSrH)rnrrVrrTrrUrrTrUrVGs z$WrappedUserFunctionVariable.__init__r9rrr3rcs,|j|t|||}|j||SrfrVrXrrTrUrMs  z)WrappedUserFunctionVariable.call_functioncs2fddjtdddS)Ncs jSrfrYrTrZrTrUr[Yrz9WrappedUserFunctionVariable.reconstruct..r/Fr\r_rTrZrUrXs z'WrappedUserFunctionVariable.reconstructr`rTrTrrUraFs racsTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr|S|Srf)r{rTensorVariableZget_real_valuer)xrTrTrUconvert_s z-invoke_and_store_as_constant..convertcsg|] }|qSrTrTrrcrdrTrUrdrz0invoke_and_store_as_constant..csi|]\}}||qSrTrTrrrrfrTrUrerz0invoke_and_store_as_constant..r)rrZregister_attr_or_moduler#)rqrrvrrrsresrTrfrUr^srcseZdZdhejZd"ddfdd ZddZdd Zd d Zd d Z de e dddZ fddZ ddZ fddZddZddZddZddd d!ZZS)#rrNrc  s| ddur| jtdtjfi| t|ts@Jt|tj sTJt|t sbJ||_ ||_ ||_ ||_||_||_||_||_dS)N mutation_typeri)rhupdater1rrVr{rrrr:r[rrRrrXrZrr wrapped_fn) rQrrRrrXrZrrrlrsrrTrUrVtsz#NestedUserFunctionVariable.__init__cCsgSrfrTrrTrTrUrsz$NestedUserFunctionVariable.self_argscCs |jSrf)rRrrrTrTrUrsz#NestedUserFunctionVariable.get_codecCstjSrfrrrTrTrUrsz&NestedUserFunctionVariable.python_typecCs|jr tt|j|j|j}|jr8|j|_ |j rJ|j |_ |j r|j }t |tr|ddlm}t||}t |tsJ||_|S)Nrr)rrrrrRrrrrXrWrZrYrr{rorrr[r)rQrArrrTrTrUrs&      z'NestedUserFunctionVariable.get_functionr9)rqname_varrcCs|jj||j|tdSrf)rr store_attrrr5)rQrqrmrrTrTrU call_setattrsz'NestedUserFunctionVariable.call_setattrcs,|dkr|j|g|RSt||||S)N __setattr__)rorrrQrqrvrrrsrrTrUrsz&NestedUserFunctionVariable.call_methodcCs |jduSrf)rrrTrTrU has_closuresz&NestedUserFunctionVariable.has_closurecs |dkr|jSt||S)Nra)rrr const_getattrrrrTrUrss z(NestedUserFunctionVariable.const_getattrcCsdSr rTrrTrTrUrsz#NestedUserFunctionVariable.has_selfcCs|jSrfrrrTrTrUrsz&NestedUserFunctionVariable.get_globalsc Cs|}t||j|j|jr,t|jjndtddt t |j D}|j rb|j |_t|j|i|}|t|j}t|jj|t|||t|j D](\}} | |vsJ|jj|} | || <q|S)Ncss|]}tdVqdSrf)r.)r_rTrTrUr.rz7NestedUserFunctionVariable.bind_args..)rrrrrrrXrorr^r]rrZZkeys_as_python_constantrYrrrapply_defaultsr[ argumentsrrrrrkr) rQrrrrsrRrAr=rrwrvrrTrTrUrs(     z$NestedUserFunctionVariable.bind_argsr7r csfdd|j|jgt|jjj|j rV|j n dg|j rz|j n dg|j r|j n dg|j rz |j }|gWnty|j Yn0n dgtdd|jrjfdd|jtddtdtddd d lm}|}|jj|r|jjj|D]2\}}|td|qdS) Ncs tdS)Nr)load_import_fromrarTr rTrUr[rz8NestedUserFunctionVariable.reconstruct..Fcs ddS)N functoolswrapsrwrTr rTrUr[ rr/rTrr8)r]rRr^Zcreate_load_const_uncheckedrr5r~rrrXZcreate_load_constrrZrrrrrlrrr9rrrZhas_pending_mutationZstore_attr_mutationsrZdup_toprn)rQrrr9rqrvrrTr rUrsV           z&NestedUserFunctionVariable.reconstruct)N)rarbrcrrrVrrrrr3rorrrrsrrrrrrTrTrrUrns.   rcsBeZdZddfdd Zddddd fd d Zd d ZZS)!WrappedNestedUserFunctionVariableNrc s|dd|dd|dd|dd|dd|dd|dd|ddt|j|j|j|j|j|j|j |j ||_ ||_ dS) NrrRrrXrZrrrl) rnrrVrrRrrXrZrrrlrTrrUrrTrUrV"s(         z*WrappedNestedUserFunctionVariable.__init__r9rrr3rcs,|j|t|||}|j||SrfrVrXrrTrUr8s  z/WrappedNestedUserFunctionVariable.call_functioncs2fddjtdddS)Ncs jSrfrYrTrZrTrUr[Drz?WrappedNestedUserFunctionVariable.reconstruct..r/Fr\r_rTrZrUrCs z-WrappedNestedUserFunctionVariable.reconstructr`rTrTrrUr|!s r|csxeZdZddhejZdddfdd ZddZed d Zd d d ddddZ d dddZ d e dddZ Z S)SkipFunctionVariablerreasonNrc s"tjfi|||_||_dSrf)rrVrr~)rQrr~rsrrTrUrVPszSkipFunctionVariable.__init__cCs|jSrfrrrTrTrUrUsz'SkipFunctionVariable.as_python_constantcCs$t|st|tj|||dSr)r,r!rr FUNCTION_MATCHrrTrTrUrXsz'SkipFunctionVariable.create_with_sourcer9rrr3rc Cst|jddrLt|jdd}tdt|jd|jd|ddgd nP|jtjjur|d d}|rr| }td d |d |dd|dgd n|jtjj ur|d d}|r| }t d|nt j rddlm}|||j}t|ts||||St|jdd} t|jdd} | dur:dnt| } zNt|j} d| d| d} d| dg}d| vr|d| dd g7}WntyTd!d"h}| |vrd#| d$| d} d%d&g}n| dur| d'rd(| d$| d$} d)g}tjj| d*d*|n6d+| d$| d,} d-d.g}tjj| d*d*|Yn0| d/krhd0} g}|jrv|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/SourcelessBuilderrczrbzz?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~r{r}rrgetfilermrOr warn_oncejoinr~)rQrqrrrsrZgraph_break_msgZskip_frame_msgrZ rebuilt_fnqualnameZ module_or module_namepathrrZknown_python_builtin_modulesr~rTrTrUras              " z"SkipFunctionVariable.call_functionrzcCstjt|j|Srf)rr5r~rrrrTrTrUrsz%SkipFunctionVariable.call_obj_hasattrrcCs&|tvrt||St||j|j|Srf)r(rrrrrrrTrTrUrs z SkipFunctionVariable.var_getattr)N)rarbrcr3rrVrrrrrrrrrTrTrrUr}Is   xr}csBeZdZddfdd Zddddd fd d Zd d ZZS)WrappedSkipFunctionVariableNrc sD|dd|ddtj|jfd|ji|||_||_dS)Nrr~)rnrrVrr~rTrrUrrTrUrVs   z$WrappedSkipFunctionVariable.__init__r9rrr3rcs,|j|t|||}|j||SrfrVrXrrTrUrs  z)WrappedSkipFunctionVariable.call_functioncs2fddjtdddS)Ncs jSrfrYrTrZrTrUr[rz9WrappedSkipFunctionVariable.reconstruct..r/Fr\r_rTrZrUrs z'WrappedSkipFunctionVariable.reconstructr`rTrTrrUrs  rcsTeZdZdZddfdd Zddfdd Zd d Zdd d ddddZZS)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". Nrc s"tjfi|||_||_dSrf)rrV wrapper_obj attr_to_trace)rQrrrsrrTrUrVsz$WrapperUserFunctionVariable.__init__r9rzcsF||jkr8t|j|j}|jo(t|j|}t|||St||Srf) rrrrr"r3r|rr)rQrqrvrrrrTrUr s  z'WrapperUserFunctionVariable.var_getattrcCsgSrfrTrrTrTrUrsz%WrapperUserFunctionVariable.self_argsrrr3rc Cs t|jdrt|j|jd}t|ddp*d}|jdddddkrd }tjj|tjjj d }| t j rtj j}t|}|d j|d jf} dt|} d | dd | dd} | t| 7} || ||} ttj||t|jg| |S)N cache_inforbrMrr/)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_argsrTrTrUrs0       z)WrapperUserFunctionVariable.call_function) rarbrcrrVrrrrrTrTrrUrsrcs.eZdZdZddfdd 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. Nrc s tj||fi|||_dSrfrI)rQrrZself_objrsrrTrUrVDsz"WrapperUserMethodVariable.__init__cCs|jgSrfrJrrTrTrUrHsz#WrapperUserMethodVariable.self_args)rarbrcrrVrrrTrTrrUr=srcCstjrddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesrrrTrTrU_traceable_collective_remapsLs  rcCs>tjsJd|tvs$J|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rrrrvaluesraZ import_sourcer")rqrZ inner_nameZ path_sourcerTrTrU_traceable_collectives_sourceWs  rcsjeZdZdZddfdd Zedddd Zed d Zeddd d ZdddddddZ 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. Nrc s,tj|fi|t|ts"J||_dSrf)rrVr{rreplacement_var)rQrrrsrrTrUrVksz*CollectiveFunctionRewriteVariable.__init__r9rzcKs6t||\}}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.rewriterrr3rc Csddlm}ddlm}t|j}t|j|i|j }d}d|vr|d rt d|jd|d|d|jgt j d |j|j|j|jfvr|d }|dur|jn |jd j}||vrtd |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[rrvrrr SUPPORTABLEZ all_reduceZreduce_scatter_tensorZ_reduce_scatter_baserhrrdefaultrrr5r~rr) rQrqrrrsdistrrZ reduce_op_varZ reduce_oprTrTrUrs<       z/CollectiveFunctionRewriteVariable.call_function) rarbrcrrVrr~rrrrrTrTrrUr`s   rcs(eZdZdddddfdd ZZS)FunctoolsWrapsVariabler9rrr3rcs6|s&tdkr&fdd}t|St||S)Nr/cs8t|tjr|jddStd|dgtjddS)Nr)rlzfunctools.wrapsz]`torch.compile` can't trace `functools.wraps` on functions defined outside the compile regionr)r{rrclonerrrrrrrTrUrzs z3FunctoolsWrapsVariable.call_function..wraps)r]rZLambdaVariablerr)rQrqrrrsrzrrrUrs z$FunctoolsWrapsVariable.call_function)rarbrcrrrTrTrrUrs rc@s(eZdZddZddddddd Zd S) CollectionsNamedTupleFunctioncCs|jSrfrrrTrTrUrsz0CollectionsNamedTupleFunction.as_python_constantr9rrr3rcCslt||}|rF|jdd|Didd|D}tj|tdStdd|d|d gtjd dS) NcSsg|] }|qSrTrrerTrTrUrrz?CollectionsNamedTupleFunction.call_function..cSsi|]\}}||qSrTrrgrTrTrUrrz?CollectionsNamedTupleFunction.call_function..rjznamedtuple constructionzargs=rz?`torch.compile` only support certain input types for namedtupler) r&rrrZUserDefinedClassVariabler2rrr)rQrqrrrs constant_argsrrTrTrUrs$  z+CollectionsNamedTupleFunction.call_functionN)rarbrcrrrTrTrTrUrs rcseZdZeddfdd ZddZddd d Zd d Zd ddddddZd e edddZ d e dddZ ddZ ddZ ZS)FunctoolsPartialVariableNrdc sPtjfi|||_t|ts&J||_t|ts:J||_t t |_ dSrf) rrVrAr{rprrr[keywordsrypartialr*Z fake_value)rQrArrrrsrrTrUrVsz!FunctoolsPartialVariable.__init__cCstjSrf)ryrrrTrTrUrsz$FunctoolsPartialVariable.python_typer7r csfdd|j|jr.|j|jsRtt|jdddS|jt |j } t|t|jd|ddS)Ncs ddS)Nryrr{rTr rTrUr[rz6FunctoolsPartialVariable.reconstruct..r/F) r]rArrforeachrr^rr]rrorCZcreate_call_function_kw)rQrrCrTr rUrs  z$FunctoolsPartialVariable.reconstructcCs|SrfrrrTrTrUr sz%FunctoolsPartialVariable.get_functionr9rrr3rcCs(|j|}i|j|}|j|||Srf)rrrrAr)rQrqrrrsZ merged_argsZ merged_kwargsrTrTrUr s z&FunctoolsPartialVariable.call_functionrcCstjttt|Srf)rr5r~rryrr*rrTrTrUrsz)FunctoolsPartialVariable.call_obj_hasattrrcCs|jot|j|}|dkr |jS|dkr8tj|j|dS|dkrbdd|jD}tj||dS|t vrvt ||St t |dS)NrArrrrcSsi|]\}}t||qSrT)r5r~rgrTrTrUr&rz8FunctoolsPartialVariable.var_getattr..) rr"rAr ListVariablerrrrConstDictVariabler(rrr)rQrqrvrrrTrTrUrs z$FunctoolsPartialVariable.var_getattrcCs:tj|jgdd|jDRidd|jDS)NcSsg|] }|qSrTrrrTrTrUr/rz?FunctoolsPartialVariable.as_python_constant..cSsi|]\}}||qSrTrrgrTrTrUr0rz?FunctoolsPartialVariable.as_python_constant..)ryrrArrrrrrrTrTrUr,sz+FunctoolsPartialVariable.as_python_constantcCs:tj|jgdd|jDRidd|jDS)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantscSsg|] }|qSrTguard_as_python_constant)rrrTrTrUr7rzEFunctoolsPartialVariable.guard_as_python_constant..cSsi|]\}}||qSrTrrgrTrTrUr8rzEFunctoolsPartialVariable.guard_as_python_constant..)ryrrArrrrrrrTrTrUr3sz1FunctoolsPartialVariable.guard_as_python_constant)rarbrcr3rVrrrrrrrrrrrTrTrrUrs   rcseZdZdddhejZeejee de fe j fdddZ edd Zed d fd d ZeedddZddZddZdddddddZddddddZddZZS) PolyfilledFunctionVariablerrl traceable_fn.rcCsiSrfrT)rrTrTrU_get_polyfill_handlersDsz1PolyfilledFunctionVariable._get_polyfill_handlerscCst|tj|||dSr)r!rr rrrTrTrUrIsz-PolyfilledFunctionVariable.create_with_sourceN)rrec stjfi|||_|||}t|sDJd|d|dD](}t||d}|rHt|shJ|}qqHtd|d||_||_ dS)NzPolyfill handler z is not callable for )Z__torch_dynamo_polyfill__Z__python_implementation__z# does not have a traceable function) rrVrrrhcallablerrrlr)rQrrshandlerZcandidate_attr candidaterrrTrUrVOs   z#PolyfilledFunctionVariable.__init__cCs|jSrf)rrrTrTrU polyfill_fnfsz&PolyfilledFunctionVariable.polyfill_fncCst|jddS)NZ*__torch_dynamo_can_constant_fold_through__F)rrlrrTrTrUcan_constant_fold_throughjsz4PolyfilledFunctionVariable.can_constant_fold_throughcCs|SrfrrrTrTrUrosz'PolyfilledFunctionVariable.get_functionr9rrr3rc Cs|rFt||rF|jdd|Didd|D}t||S|jtjurt|dkr|st |dt j t j frt dd|djDrt jj||jd tjtd d|djDfitd d|djDd St||j}||||S) NcSsg|] }|qSrTrrerTrTrUr}rz.cSsi|]\}}||qSrTrrgrTrTrUr~rz.r/rcss>|]6}t|tjrt|jtp4t|tjo4|tuVqdSrf)r{rr5rintSymNodeVariablerrerTrTrUr.sz;PolyfilledFunctionVariable.call_function..rcss|]}|VqdSrfas_proxy)rarTrTrUr.rcSs$g|]}t|tjr|jn|jqSrT)r{rr5rsym_numrerTrTrUrs )r)rr'rrr3r|r<sumr]r{rr TupleVariabler3rr~r create_proxyrZsym_sumrorr)rQrqrrrsrZtraceable_function_variablerTrTrUrrsL      z(PolyfilledFunctionVariable.call_functionrrrsrecCs|dkr||||St|j|d}|dusBJd|d|jt|s`Jd|d|ji}|jrzt|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_methodcCs|jSrfrrrTrTrUrsz-PolyfilledFunctionVariable.as_python_constant)rarbrcr3rrrycacher[rrrrrrr<rVpropertyrrrrrrrrTrTrrUr<s4$  8 rc@seZdZddZdS)TracebackVariablecCsdSrfrTrrTrTrUrrzTracebackVariable.call_functionNrarbrcrrTrTrTrUrsrcs4eZdZfddZddZddZddZZS) SysFunctionVariablec stjfi|||_dSrf)rrVr)rQrrsrrTrUrVszSysFunctionVariable.__init__cCs`t|jr:|jd}|j}d}t|||t||g}ntdtdtdg}t|S)Nr)r]Z exn_vt_stackr9r3r|rr5r)rQrqZexnrtbrrTrTrUexc_infos    zSysFunctionVariable.exc_infocCs||jdSrQ)rrrrTrTrU exceptionszSysFunctionVariable.exceptioncCs0|jtjur||S|jtjus&J||Srf)rr5rrrrTrTrUrs  z!SysFunctionVariable.call_function)rarbrcrVrrrrrTrTrrUrs r) create_tma_experimental_metadatacreate_tma_stable_metadataTMADescriptorMetadataTritonHOPifierc@seZdZeedddZeedddZeeddd Z e e j j jd fd d d ZddZddZddZddZeedddZdeeddddZed ddZdS) DynamoTritonHOPifier)rrecCs t|dSrf)r)rQrrTrTrUraise_unsupportedsz&DynamoTritonHOPifier.raise_unsupported)maybe_callablerecCst|ttfSrf)r{rr)rQrrTrTrU is_callablesz DynamoTritonHOPifier.is_callable)rrecCs|jSrfr)rQrrTrTrU get_valueszDynamoTritonHOPifier.get_value.rcCsBddlm}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)listsrr{rrrrr)rQgridrrTrTrU check_grids   zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSsi|]\}}tj||qSrTrr5r~rgrTrTrUrrz2DynamoTritonHOPifier.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)NcSsg|] }|qSrTr)rrrTrTrUr rz=DynamoTritonHOPifier.maybe_unpack_configs..)Zunpack_var_sequence)rQZconfigsrqrTrTrUmaybe_unpack_configss z)DynamoTritonHOPifier.maybe_unpack_configs)rrecCs|s|d|S)Nz`@triton.heuristics must return constant values because configs can only contain constant values.)Zis_python_constantrr)rQrrTrTrUmaybe_unpack_heuristic_result$s z2DynamoTritonHOPifier.maybe_unpack_heuristic_resultTritonKernelVariable)rrrrecCs>|jdust|dkr |dt||j|j|d|jdS)Nr/z7Triton kernels should be called with only a single gridr)kernel kernel_idxrr)rr]rrrrr)rQrrrrTrTrU call_getitem.sz!DynamoTritonHOPifier.call_getitemc s*ddlmddlm}i}t|D]2}||}t|ttfr(| ||<| ||<q(dd| D} ddl m } m} fdd| D} fd d| D} | D]4}|}t|tjtjfs|d t|d q| | }|| t}|jd | d |j||||dtdS)Nr/r4)rcSsi|]\}}tj||qSrTrrgrTrTrUrSsz1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSrT)r{rrgr4rTrUr`s cs i|]\}}t|s||qSrT)r{rgr4rTrUres z.Unexpected argument type for a Triton kernel: rrrT)rconstant_args_idxrtma_descriptor_metadatars)rNr5ZdictsrrprCr{!TMADescriptorExperimentalVariableTMADescriptorStableVariable to_metadata get_tensorr*torch._higher_order_ops.triton_kernel_wraprrrZrealizerrbrrreprZadd_constant_argsr[rrrr)rQrZgridsZcombined_args_rawrqrrrrZ combined_argsrrrZnon_constant_argsrrrTr4rUcall_HOP@sT         zDynamoTritonHOPifier.call_HOPN)rarbrcrr rrr=rrrorZfxproxyZProxyrrrrrrrrr5rrTrTrTrUrs   rcseZdZUded<ded<eeed<ded<dd fd d Zd d dddddZd dddfdd Ze e dddZ Z S)rr:rr;rrr"rNrc s4|dd|_tjfi|t||||dS)Nr)rnrrrV dynamo_triton_hopifier_singletonZ init_variable)rQrrrrsrrTrUrVszTritonKernelVariable.__init__r9rrr3rcCst||||Srf)r Zcall_triton_kernelrrTrTrUrsz"TritonKernelVariable.call_functionrcs>|dkrt||S|dkr,t||||St||||S)N __getitem__run)r rZcall_runrrrqrrTrUrs  z TritonKernelVariable.call_method)rrecCs4ddlm}ddlm}t||r0||S|S)Nr/r4)r)rNr5tensorrr{r~Z evaluate_expr)rQrr5rrTrTrUspecialize_symbolics    z(TritonKernelVariable.specialize_symbolic) rarbrcrrrrVrrrrrrTrTrrUrs   rcsFeZdZdddddfdd ZddZd d d d Zd dZZS)rzvariables.DataPtrVariablezlist[ConstantVariable]r5data_ptrdims block_dims element_sizec s>t|tjsJtjfi|||_||_||_||_dSrf) r{rDataPtrVariablerrVrrrr)rQrrrrrsrrTrUrVs z*TMADescriptorExperimentalVariable.__init__cCs*tdd|jDdd|jD|jS)NcSsg|] }|qSrTrrdimrTrTrUrrzATMADescriptorExperimentalVariable.to_metadata..cSsg|] }|qSrTrrrTrTrUrr)rrrrrrrTrTrUrs z-TMADescriptorExperimentalVariable.to_metadatar7r csXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorZcreate_Zd_tma_descriptor)rwr]rrTrZrTrUr[sz?TMADescriptorExperimentalVariable.reconstruct..r/F) r]rrrrrrrr])rQrrrrTrZrUrs   z-TMADescriptorExperimentalVariable.reconstructcCs|jjSrf)r from_tensorrrTrTrUrsz,TMADescriptorExperimentalVariable.get_tensorrarbrcrVrrrrrTrTrrUrs rcsHeZdZdddfdd ZddZdd d d Zdd d dZZS)rzvariables.TensorVariablezvariables.ListVariabler  block_shapec s2t|tjsJtjfi|||_||_dSrf)r{rrbrrVr r)rQr rrsrrTrUrVsz$TMADescriptorStableVariable.__init__cCst|jSrf)rrrrrTrTrUrsz'TMADescriptorStableVariable.to_metadatar7r cs@fddd|j|jddS)Ncs ddS)Nztriton.tools.tensor_descriptorZTensorDescriptorr{rTr rTrUr[sz9TMADescriptorStableVariable.reconstruct..rr)r]Z load_methodr rrrr_rTr rUrs    z'TMADescriptorStableVariable.reconstructrcCs|jSrf)r rrTrTrUrsz&TMADescriptorStableVariable.get_tensorrrTrTrrUrs   rcs8eZdZeddfdd Zddddd d d ZZS) 'CreateTMADescriptorExperimentalVariableN)rankrec s(|dvs Jtjfi|||_dS)N)r/r)rrVr)rQrrsrrTrUrV s z0CreateTMADescriptorExperimentalVariable.__init__r9rrr3rcCs0d|vr|dn|d}t|tjs6td|jd|jdkrt|t|dksXJd|vrh|dn|dg}d|vr|dn|d g}nxt|t|d ksJd |vr|d n|dd |vr|d n|d g}d |vr|d n|dd|vr|dn|dg}d|vr|dn|d}t||||dS)Nptrrz8Please ensure there were no graph breaks between create_z3d_tma_descriptor and the upstream .data_ptr() call.r/r>rZ block_dimrZdim1Zdim0Z block_dim1r0Z block_dim0rrr)r{rrrrr]r)rQrqrrrsrrrrrTrTrUr s6  z5CreateTMADescriptorExperimentalVariable.call_function)rarbrcrrVrrrTrTrrUrs rc@s eZdZdddddddZdS) !CreateTMADescriptorStableVariabler9rrr3rcCs<d|vr|dn|d}d|vr(|dn|d}t||dS)Nr rrr/r)r)rQrqrrrsr rrTrTrUr5 s z/CreateTMADescriptorStableVariable.call_functionNrrTrTrTrUr4 s r)N)rr<ryrrrr5rrcollections.abcrrtypingrrrrr Ztyping_extensionsr Z unittest.mockr weakrefr rZtorch._dynamo.excr rMrrrrZbytecode_transformationrrrr(rrrrrrrrrrZguardsr r!rr"r#r$r%rr&r'r(r)r*r+r,r-r.baser0r1r2r3rNr5Z#torch.distributed.fsdp._fully_shardr6ModuleNotFoundErrorZtorch._dynamo.codegenr7rr9rr:r;r<rMrOrgr@rjryrlrr[rrrrrrrrrr>r?rFrGrSrarrr|r}rrrrrrrrrrrrrrrrrr rrrrrrTrTrTrUs      0 ,      5  "[B  7 Y4(A  TQ!.'!5