o ߗi@sddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZddlmZddlZddlmZmZddlmZmZddlmZmZddlmZmZdd lmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*d d l+m,Z,m-Z-m.Z.d d l/m0Z0zddl1m2Z2Wn e3ydZ2Ynwe rddl4m5Z5ddl6m7Z7m8Z8ededZ9dCdDddZ:dDddZ;de eGddde.Z?Gd d!d!e?Z@Gd"d#d#e@ZAGd$d%d%eAZBGd&d'd'e@ZCdDd(d)ZDGd*d+d+e?ZEGd,d-d-e.ZFGd.d/d/e.ZGd0d1ZHdDd2d3ZIGd4d5d5e@ZJGd6d7d7e.ZKGd8d9d9e.ZLdd:l6mMZMmNZNGd;d<dd>e.ZQGd?d@d@e.ZRGdAdBdBe.ZSdS)EN)AnyCallableDictListOptionalTuple TYPE_CHECKINGTypeVar)Never) polyfills variables)create_call_function create_rot_n) unimplemented Unsupported) GuardBuilder install_guard) AttrSourceConstantSourceDefaultsSource GetItemSource)check_constant_argscheck_unspec_or_constant_argsidentity is_functionis_wrapper_or_member_descriptoristype make_cell)typestrValueMutationNewVariableTrackerConstantVariable)_fsdp_param_group)InstructionTranslator)TritonGridTypeTritonKernelType_F)boundtxr&cCs,t|tr|S|st||Stj||SN) isinstancer"buildr LazyVariableTrackercreate)r+valsourcer3_/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/torch/_dynamo/variables/functions.pywrap_bound_arg1s  r5cCs6t|D]\}}t|ttfrt||||<qdSr,)listitemsr-tupledictr5)r+resultkvr3r3r4wrap_args_kwargs=s r=r:cCsB|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)parentr:coder?namenew_cellr3r3r4 init_cellvarsDs  rHc Csdddlm}||||||}||_t|tr"ddlm} t| |}|dus-t|ts-J||_|S)Nr) FunctionTypepairwise) typesrI__kwdefaults__r-r8 itertoolsrKr9__annotations__) rE f_globalsrFdefaultsclosure kwdefaults annotationsrIfuncrKr3r3r4_create_nested_fnUs    rVc@s\eZdZddZddZ     dd dZddded efddZddZ ddZ dS)BaseUserFunctionVariablecC |jSr,)get_code co_filenameselfr3r3r4 get_filenamej z%BaseUserFunctionVariable.get_filenamecCrXr,)rYco_namer[r3r3r4get_namemr^z!BaseUserFunctionVariable.get_namer+r&argsList[VariableTracker]kwargsDict[str, VariableTracker]returnr"cCs||g|||Sr,)inline_user_function_return self_argsr\r+rarcr3r3r4 call_functionpsz&BaseUserFunctionVariable.call_functionrFcCsLd}z t||}Wnty|dkrt|trd}Ynwtj|S)NF__name__T)hasattr get_functionNotImplementedErrorr-NestedUserFunctionVariabler r$r0r\r+rFr:r3r3r4 call_hasattrxs  z%BaseUserFunctionVariable.call_hasattrcCstt|jSr,)r6inspect signaturerl parametersr[r3r3r4inspect_parameter_namessz0BaseUserFunctionVariable.inspect_parameter_namescCiSr,r3)r\r+r3r3r4 closure_varsz%BaseUserFunctionVariable.closure_varsNr+r&rarbrcrdrer") rj __module__ __qualname__r]r`ristrr"rprtrvr3r3r3r4rWis  rWcseZdZdZddhejZeddZd)d*fd d Zfd d Z d dZ ddZ ddZ ddZ ddZddZdeeeffddZdddefddZdddedefd d!Z   " # $ %  &d+fd'd( ZZS),UserFunctionVariablez-Some unsupported user-defined global functionfn is_constantcCt|tj|||dSNr2)r make_guardr CLOSURE_MATCHclsvaluer2r3r3r4create_with_sources z'UserFunctionVariable.create_with_sourceFreNc sptjdi|t|ddrd|_nd|_t|tjtjj fs,Jdt |d|t |d|}||_ dS)N_dynamo_marked_constantFTzexpected FunctionType found  _torchdynamo_inliner3)super__init__getattrr~r-rLrItorchjitScriptFunctionr rqgetattr_staticr})r\r}r~rc __class__r3r4rs  zUserFunctionVariable.__init__cst|tr|jStSr,)rr|r}ras_python_constantr[rr3r4rs  z'UserFunctionVariable.as_python_constantcCgSr,r3r[r3r3r4rgrwzUserFunctionVariable.self_argscC|jSr,r}r[r3r3r4rlz!UserFunctionVariable.get_functioncC|jjSr,)r}__code__r[r3r3r4rYzUserFunctionVariable.get_codecCtjSr,)rLrIr[r3r3r4 python_typerz UserFunctionVariable.python_typecCst|jddduS)N__self__)rr}r[r3r3r4has_selfzUserFunctionVariable.has_selfcCrr,)r} __globals__r[r3r3r4 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. )r+cs*g|]\}}jdur dntj|qSr,r2r).0idx_r[r3r4 sz2UserFunctionVariable.bind_args..csg|] \}}||dqS)r1r2r3)rargr2)wrapr3r4rs cs,i|]}|jdur dntj|ddqS)NT)is_kwr)rr;r[r3r4 s z2UserFunctionVariable.bind_args..cs"i|] \}}|||dqSrr3rr;r<)kwdefaults_sourcesrr3r4rsr3 __closure__ cell_contentsN)*r~r>root_tx functoolspartialr5r} __defaults__ enumeraterLrIrrrjr8ziprrMr7rqrrbindapply_defaultsr9 argumentsr=rHlen co_freevarsrNcountr?r2rrr"r.r ValueErrorr DeletedVariabletrack_cell_existing)r\rDrarcrr}rQdefaults_sources fake_funcr*r:rRrrFcellr?cell_var closure_cellclosure_cell_contents contents_varr3)rr\rr4 bind_argss|                zUserFunctionVariable.bind_argsr+r&rFcCsf|jot|j|}z t|j|}Wnty#tj|||dYSw|r-tj ||St ||Sr) r2rrqrr}AttributeErrorr GetAttrVariabler/r0r"r.)r\r+rFr2subobjr3r3r4 var_getattrs  z UserFunctionVariable.var_getattrcCst|j|}tj|Sr,)rkr}r r$r0ror3r3r4rp!s  z!UserFunctionVariable.call_hasattrrarbrcrdr"cs|jrt||j|||S|jjjrX|jjjsXzddlm }Wn t y+d}Ynw|durX|j|j |j fvrXt jj|t|||WdS1sSwYt|||S)Nr) FSDPState)r~invoke_and_store_as_constantr}r`r>current_tracerunder_activation_checkpoint#allow_side_effects_under_checkpoint/torch.distributed.fsdp._fully_shard._fsdp_stater Exception _pre_forward _post_forwardr_dynamor?rri)r\r+rarcrrr3r4ri%s*   z"UserFunctionVariable.call_function)FreNrx)rjryrz__doc__rW_nonvar_fields classmethodrrrrgrlrYrrrrr{r"rrrpri __classcell__r3r3rr4r|s:  W r|csjeZdZdZdfdd ZdefddZdd Zd d Z      dfdd Z fddZ Z S)UserMethodVariablez$Some unsupported user-defined methodreNc s tjdd|i|||_dS)Nr}r3)rrobj)r\r}rrcrr3r4rCs zUserMethodVariable.__init__cCs|jjd|jd|jdS)N(z, ))rrjr}rr[r3r3r4__repr__GszUserMethodVariable.__repr__cCs|jgSr,)rr[r3r3r4rgJrzUserMethodVariable.self_argscCrr,)rL MethodTyper[r3r3r4rMrzUserMethodVariable.python_typer+r&rarbrcrdr"cs|jr2t|jtjr2t|jdd}|dur |dr |dks#|j r1|jj ||jj |||j dSnt durM|jt j jurMt|j||jg|R|S|j rct|jj|jj }t|||||St|||S)Nryz torch.nn.ztorch.nn.utils.parametrize)constant)r>is_root_tracerr-rr NNModuleVariablerr} startswithr~ call_methodrjr%FSDPParamGroupuse_training_stateTorchCtxManagerClassVariablerirrr`r)r\r+rarc module_attrr}rr3r4riPs.  z UserMethodVariable.call_functioncstddS)Nr)rrtr[rr3r4rt|rz*UserMethodVariable.inspect_parameter_namesrrx) rjryrzrrr{rrgrrirtrr3r3rr4r@s ,rc<eZdZdfdd Z      dfd d ZZS)WrappedUserMethodVariablereNc sB|dd|ddtj|j|jfi|||_||_dSNr}r)rCrrr}rwrappedcontextr\rrrcrr3r4rs   z"WrappedUserMethodVariable.__init__r+r&rarbrcrdr"c,|j|t|||}|j||Sr,renterrriexitr\r+rarcr:rr3r4ri  z'WrappedUserMethodVariable.call_functionrrxrjryrzrrirr3r3rr4rrcr)WrappedUserFunctionVariablereNc s>|dd|ddtj|jfi|||_||_dSr)rCrrr}rrrrr3r4rs   z$WrappedUserFunctionVariable.__init__r+r&rarbrcrdr"crr,rrrr3r4rirz)WrappedUserFunctionVariable.call_functionrrxrr3r3rr4rrrcsTddfdd|D}fdd|D}||i|}|jj||t|dS)NcSst|tjr |S|Sr,)r-r TensorVariableget_real_valuer)xr3r3r4converts z-invoke_and_store_as_constant..convertcsg|]}|qSr3r3rrrr3r4rz0invoke_and_store_as_constant..csi|] \}}||qSr3r3rrr3r4rz0invoke_and_store_as_constant..r)r7r>register_attr_or_moduler)r+r}rFrarcresr3rr4rsrcspeZdZdhejZ d dfdd ZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ZS)rnrPNrec  sztjdi| t|tsJt|tjsJt|ts#J||_||_ ||_ ||_ ||_ ||_ ||_||_dSNr3)rrr-rr{rLCodeTyper9fn_namerErPrQrSrTrR wrapped_fn) r\rrErPrQrSrTrRrrcrr3r4rs z#NestedUserFunctionVariable.__init__cCrr,r3r[r3r3r4rgrwz$NestedUserFunctionVariable.self_argscCs |jSr,)rErr[r3r3r4rYr^z#NestedUserFunctionVariable.get_codecCs|jrtt|j|j|j}|jr|j|_ |j r%|j |_ |j rH|j }t |tr>ddlm}t||}t |tsEJ||_|S)NrrJ)rRrmrLrIrErrPrrQrrSrMrTr-r8rNrKr9rO)r\rUrTrKr3r3r4rls&      z'NestedUserFunctionVariable.get_functioncCs |jduSr,)rRr[r3r3r4 has_closurer^z&NestedUserFunctionVariable.has_closurecCsdS)NFr3r[r3r3r4rrwz#NestedUserFunctionVariable.has_selfcCrr,)rPr[r3r3r4rrz&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|]}tdVqdSr,)r)rrr3r3r4 z7NestedUserFunctionVariable.bind_args..)rYrLrIrPrrrQr8r7rangerrrSkeys_as_python_constantrMrqrrrrr9rr=r>rrHrrR) r\rDrarcrErUr*r:rrFrr3r3r4rs(     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)NrV)load_import_fromrjr3codegenr3r4 z8NestedUserFunctionVariable.reconstruct..Fc ddS)Nrwrapsr r3rr3r4r>rrr T) add_push_nullrE extend_outputcreate_load_const_uncheckedrPr$r0rr_rQcreate_load_constrRrSrTrrmrrr)r\rrTr3rr4 reconstructsF          z&NestedUserFunctionVariable.reconstructr,r)rjryrzrWrrrgrYrlrrrrrrr3r3rr4rns" rncsreZdZddhejZddfdd ZddZed d Ze e dd d Z       dddZ ZS)SkipFunctionVariablerreasonNrec "tjdi|||_||_dSr)rrrr)r\rrrcrr3r4rM zSkipFunctionVariable.__init__cCrr,rr[r3r3r4rRrz'SkipFunctionVariable.as_python_constantcCs$t|s t|tj|||dSr)rrrrFUNCTION_MATCHrr3r3r4rUs z'SkipFunctionVariable.create_with_sourcecCs tjtjiSr,) collections namedtupler UserDefinedClassVariabler3r3r3r4 fold_through_function_to_wrapper^sz5SkipFunctionVariable.fold_through_function_to_wrapperr+r&rarbrcrdr"c st|jddrtd|jdS|j|vrAt|rA|jddDidd|D}||j|t dS|jt j urZ|sZt d krZfd d }t |Szt|j}d |jjd |d}WnWtyddh}|jj|vrd|jjd|jjd}n6|jjdur|jjdrd|jjd|jjd}tjj|nd|jjd|jjd}tjj|Ynw|jjdkrd}||jrd|jdnd7}t|dS)N_torchdynamo_disableFz.call torch._dynamo.disable() wrapped function cSg|]}|qSr3rrr3r3r4rtrz6SkipFunctionVariable.call_function..cSi|] \}}||qSr3r'rr3r3r4rurz6SkipFunctionVariable.call_function..) mutation_typercs0t|tjr|jddStd|ddS)Nr)rzfunctools.wraps(r)r-r rnclonerrrar3r4r|s z1SkipFunctionVariable.call_function..wrapsz'skip function z in file '_abc _warningsz.Graph break due to unsupported Python builtin .zM. Please file an issue on GitHub so the PyTorch team can add support for it. optreez)Graph break for an optree C/C++ function zj. Consider using torch.utils._pytree - https://github.com/pytorch/pytorch/blob/main/torch/utils/_pytree.pyz'Graph break due to unsupported builtin a. This function is either a Python builtin (e.g. _warnings.warn) or a third-party C/C++ Python extension (perhaps created with pybind). If 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. If 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.z', r)rqrrrr$keysrr7getr!rrrr LambdaVariablegetfilerz TypeErrorryrrrutils warn_oncer) r\r+rarcrrpathmsgknown_python_builtin_modulesr3r+r4riesP          " z"SkipFunctionVariable.call_functionr,rrx)rjryrzr"rrrrr staticmethodr lru_cacher$rirr3r3rr4rFs,  rcsJeZdZdZdfdd 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". reNc rr)rr wrapper_obj attr_to_trace)r\r?r@rcrr3r4rrz$WrapperUserFunctionVariable.__init__r+r&csF||jkrt|j|j}|jot|j|}t|||St||Sr,) r@rr?r2rr"r.rr)r\r+rFr1r2rr3r4rs z'WrapperUserFunctionVariable.var_getattrrarbrcrdr"cCs&ttj||t|jg||Sr,)r r|r getattr_and_tracerir$r@rhr3r3r4risz)WrapperUserFunctionVariable.call_functionrr+r&rx)rjryrzrrrrirr3r3rr4r>sr>cCstjr ddlm}|SiS)Nrtraceable_collective_remaps)r distributed is_available)torch.distributed._functional_collectivesrDrCr3r3r4_traceable_collective_remapss  rHcCs>tjs Jd|tvsJ|j}|d}t||S)NzIllegal invocation.z)torch.distributed._functional_collectives)rrErFrHvaluesrj import_sourcer)r+r} inner_name path_sourcer3r3r4_traceable_collectives_sources   rMcsdeZdZdZdfdd 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||_dSr,)rrr-r|replacement_var)r\r}rOrcrr3r4rs z*CollectiveFunctionRewriteVariable.__init__r+r&cKs6t||\}}t|ft|fd|i||d|S)Nr2)rOr2)rNrewriter|)r+old_fnr2optionsnew_fn new_sourcer3r3r4r0sz(CollectiveFunctionRewriteVariable.createcCst|o |tvSr,)rq isfunctionrH)variabler3r3r4 can_rewritesz-CollectiveFunctionRewriteVariable.can_rewritecCst|}|t||fSr,)rHrM)r+r}rSr3r3r4rPs z)CollectiveFunctionRewriteVariable.rewriterarbrcrdr"c Csddlm}ddlm}t|j}t|j|i|j }d}d|vr1|d r1t d|j|j|j |j |jfvrc|d}|durH|jn|jdj}||vrYtd|tj|||d<|j|||S)Nr)REDUCE_OP_TO_STRr3async_opzBCollectiveFunctionRewriteVariable can't support async_op=True for opzUnsupported all_reduce op: )torch.distributedrErGrXrqrrr}r9rrrr all_reducereduce_scatter_tensor_reduce_scatter_baser3rrsdefaultrr r$r0rOri) r\r+rarcdistrXrr reduce_op_var reduce_opr3r3r4ri s2     z/CollectiveFunctionRewriteVariable.call_functionrrBrx) rjryrzrrr<r0rWrPrirr3r3rr4rNs$    rNcsveZdZdeddffdd ZddZdd Z    dddZd d dedefddZ ddZ ddZ Z S)FunctoolsPartialVariablerUreNc sDtjdi|||_t|tsJ||_t|tsJ||_dSr)rrrUr-r6rar9keywords)r\rUrardrcrr3r4r8s  z!FunctoolsPartialVariable.__init__csfdd|j|jr|j|js)tt|jdddS|jt |j } t|t|jd|ddS)Ncr)Nrrrr3rr3r4rArz6FunctoolsPartialVariable.reconstruct..rF) rrUraforeachrdrrrrIr8r2create_call_function_kw)r\rr2r3rr4r@s  z$FunctoolsPartialVariable.reconstructcC|Sr,r'r[r3r3r4rlOrz%FunctoolsPartialVariable.get_functionr+r&rarbrcrdr"cCs(|j|}i|j|}|j|||Sr,)rardrUri)r\r+rarc merged_args merged_kwargsr3r3r4riRs z&FunctoolsPartialVariable.call_functionrFcCstjttt|Sr,)r r$r0rkrrr)r\r+rFr3r3r4rp\sz%FunctoolsPartialVariable.call_hasattrcC:tj|jgdd|jDRidd|jDS)NcSr&r3r')rrr3r3r4rerz?FunctoolsPartialVariable.as_python_constant..cSr(r3r'rr3r3r4rfrz?FunctoolsPartialVariable.as_python_constant..)rrrUrrardr7r[r3r3r4rbsz+FunctoolsPartialVariable.as_python_constantcCrj)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantscSr&r3guard_as_python_constant)rr<r3r3r4rmrzEFunctoolsPartialVariable.guard_as_python_constant..cSr(r3rkrr3r3r4rnrzEFunctoolsPartialVariable.guard_as_python_constant..)rrrUrlrardr7r[r3r3r4rlisz1FunctoolsPartialVariable.guard_as_python_constantrx) rjryrzr"rrrlrir{rprrlrr3r3rr4rc7s   rccseZdZdddhejZeeddee de fe j ffddZ ed d Zdeddffd d Zedefd dZddZddZ        d ddZ      d!ddZddZZS)"PolyfilledFunctionVariabler}r traceable_fnNre.cCrur,r3)rr3r3r4_get_polyfill_handlerszsz1PolyfilledFunctionVariable._get_polyfill_handlerscCrr)rrrr rr3r3r4rs 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 functionr3) rrr}ror3callabler RuntimeErrorrrn)r\r}rchandlercandidate_attr candidaternrr3r4rs     z#PolyfilledFunctionVariable.__init__cCrr,)rnr[r3r3r4 polyfill_fnsz&PolyfilledFunctionVariable.polyfill_fncCst|jddS)N*__torch_dynamo_can_constant_fold_through__F)rrr[r3r3r4can_constant_fold_throughz4PolyfilledFunctionVariable.can_constant_fold_throughcCrgr,r'r[r3r3r4rlrz'PolyfilledFunctionVariable.get_functionr+r&rarbrcrdr"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) NcSr&r3r'rr3r3r4rrz.cSr(r3r'rr3r3r4rrz.rrcss@|]}t|tjrt|jtpt|tjo|tuVqdSr,)r-r r$rintSymNodeVariablerrr3r3r4r s  z;PolyfilledFunctionVariable.call_function..ricss|]}|VqdSr,as_proxy)rar3r3r4r r cSs$g|]}t|tjr |jn|jqSr3)r-r r$rsym_numrr3r3r4rs  )r)ryrr}r7r"r.builtinssumrr-r ListVariable TupleVariableallr|r0r> create_proxyrsym_sumr8rnri)r\r+rarcr:traceable_function_variabler3r3r4risH      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 r2)rirr}rr2rrm)r\r+rFrarcmethodrRpolyfilled_method_variabler3r3r4rsz&PolyfilledFunctionVariable.call_methodcCrr,rr[r3r3r4rrz-PolyfilledFunctionVariable.as_python_constantrxrarbrcrdrer")rjryrzr"rrrr=rrrrLrIrorr)rpropertyrwryrlrirrrr3r3rr4rmrsD$  4 rm)TMADescriptorMetadataTritonHOPifierc@steZdZdedefddZdedefddZdedefd d Z de e j j jd ffd d ZddZdefddZdS)DynamoTritonHOPifierr:recCst|r,)r)r\r:r3r3r4raise_unsupportedrz&DynamoTritonHOPifier.raise_unsupportedmaybe_callablecCst|ttfSr,)r-rnr|)r\rr3r3r4 is_callablerzz DynamoTritonHOPifier.is_callabler1cCs|jSr,r)r\r1r3r3r4 get_valuerzDynamoTritonHOPifier.get_value.cCs4ddlm}t||r|Stdt|dS)Nr)BaseListVariablezgrid for the triton kernel is )listsrr-r~rtype)r\gridrr3r3r4 check_grids  zDynamoTritonHOPifier.check_gridcCs&dd|D}|||gi}|S)NcSi|] \}}tj||qSr3r r$r0rr3r3r4rsz2DynamoTritonHOPifier.call_grid..)r7ri)r\rmetar+r3r3r4 call_grid szDynamoTritonHOPifier.call_gridc 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)Nrr#)ConstDictVariablecSrr3rrr3r3r4r"s z1DynamoTritonHOPifier.call_HOP..r)kernel_side_tabletriton_kernel_wrapper_mutationcs$i|]\}}t|r||qSr3)r-rrr#r3r4r/s cs i|] \}}t|s||qSr3)r-rr#r3r4r4s z.Unexpected argument type for a Triton kernel: r/rir3) kernel_idxconstant_args_idxrtma_descriptor_metadatarc)rr$dictsrr6r2r-TMADescriptorVariable to_metadatadata_ptr from_tensorr7*torch._higher_order_ops.triton_kernel_wraprrrIrealizer rr|rrepradd_constant_argsr9r>rrr~)r\rVgridscombined_args_rawr+rrr;r< combined_argsrr constant_argsnon_constant_argsrrr3r#r4call_HOPsT           zDynamoTritonHOPifier.call_HOPN)rjryrzr{r rrboolrrrrfxproxyProxyrrr$rr3r3r3r4rsrcseZdZUded<ded<eeed<dfdd Z    dddZ    dfdd Zde de fddZ Z S)TritonKernelVariabler'rr(kernelrreNc s&tjdi|t||||dSr)rr dynamo_triton_hopifier_singleton init_variable)r\rrrrcrr3r4r]szTritonKernelVariable.__init__r+r&rarbrcrdr"cCst||||Sr,)rcall_triton_kernelrhr3r3r4riasz"TritonKernelVariable.call_functioncs>|dkr t||S|dkrt||||St||||S)N __getitem__run)r call_getitemcall_runrr)r\r+rFrarcrr3r4rks  z TritonKernelVariable.call_methodrcCs4ddlm}ddlm}t||r||S|S)Nrr#)r|)rr$tensorr|r-r0 evaluate_expr)r\rr$r|r3r3r4specialize_symboliczs   z(TritonKernelVariable.specialize_symbolicrrxr) rjryrzrOrr{rrirrrrr3r3rr4rXs,    rcs>eZdZ        dfdd Zd d Zd d ZZS)rrvariables.DataPtrVariabledimsList[ConstantVariable] block_dims element_sizer$c s>t|tjsJtjdi|||_||_||_||_dSr) r-r DataPtrVariablerrrrrr)r\rrrrrcrr3r4rs  zTMADescriptorVariable.__init__cCs(dd|jDdd|jD|jfS)NcSr&r3r}rdimr3r3r4rrz5TMADescriptorVariable.to_metadata..cSr&r3r}rr3r3r4rr)rrrr~r[r3r3r4rsz!TMADescriptorVariable.to_metadatacsXfddjgjjj}|t|dddS)NcsddtjdS)Nz$triton.tools.experimental_descriptorcreate_d_tma_descriptor)r rrr3rr\r3r4rsz3TMADescriptorVariable.reconstruct..rF) rrrrrrrerir)r\rrar3rr4rs   z!TMADescriptorVariable.reconstruct)rrrrrrrr$)rjryrzrrrrr3r3rr4rsrcs@eZdZdeddffdd Z     dd dZZS)CreateTMADescriptorVariablerankreNc s(|dvsJtjdi|||_dS)N)rr r3)rrr)r\rrcrr3r4rs  z$CreateTMADescriptorVariable.__init__r+r&rarbrcrdr"cCs.d|vr|dn|d}t|tjstd|jd|jdkrGt|t|dks,Jd|vr4|dn|dg}d|vrA|dn|d g}nrHrMrNrcrmrrrrrrrr3r3r3r4sj( $       8@ l"  O;\,$