i6ddlmZddlZddlZddlZddlmZddlmZddl m Z m Z m Z m Z ddlmZddlZddlZddlZddlmZmZmZmZmZddlmZe rdd lmZd ad ad ad(d)d Z d*d Z!Gd dZ"d+dZ#dZ$dZ%dZ&d,dZ'd-dZ(d.d/dZ)ejTd.d0dZ+ejTdZ,Gdde"Z-Gdde Z.d1dZ/d2dZ0d3dZ1d4dZ2d5d Z3eGd!d"Z4eGd#d$Z5ejld6d%Z7 d7d&Z8d'Z9y)8) annotationsN)deque) dataclass)castoverloadProtocol TYPE_CHECKING)TypeIs)_get_dispatch_stack_at_len_torch_dispatch_stack_pop_torch_dispatch_stack_push_on_torch_dispatch_stack DispatchKey)/set_is_in_mode_without_ignore_compile_internals)SequenceFc|rtStSN)_is_in_torch_dispatch_mode$_is_in_non_infra_torch_dispatch_mode)include_infra_modess V/var/www/html/engine/venv/lib/python3.12/site-packages/torch/utils/_python_dispatch.pyis_in_torch_dispatch_moder)s  #2ctSr)0_is_in_any_mode_without_ignore_compile_internalsrr/is_in_any_mode_without_ignore_compile_internalsr1s ;;rcneZdZdZdZd d dZd dZddZdZdZ e d Z e dd Z e dd Z y)TorchDispatchModea A ``TorchDispatchMode`` allows you to override the meaning of all ``__torch_dispatch__`` overrideable functions within a dynamic scope, without having to actually create a tensor subclass or manually monkey-patch functions in the PyTorch API. Some common situations where you should use a mode: * You want to override the meaning of factory functions, or other functions that do not otherwise take a tensor as an argument (these cannot be overridden with tensor subclasses). * You want to override the behavior of all functions without needing to wrap your inputs in tensor subclasses; e.g., if you are just interested in logging intermediate computations. * You want to control the order of execution of various tensor subclasses explicitly, rather than implicitly via the return of ``NotImplemented``. Independent subclasses of :class:`TorchDispatchMode` are compositional: modes can be pushed onto a stack using ``with MyMode():``. When you call functions in the PyTorch API inside your ``__torch_dispatch__`` implementation, by default, they will forward on to the next mode on the mode stack. If you want recursively call back into your current ``__torch_dispatch__`` implementation, either explicitly invoke ``self.__torch_dispatch__(...)``, or use the context manager ``self`` to make PyTorch API self-referential (beware of infinite loops, in this case!) FNc|>t|tjjs t d||j d<t |_t |_t |_ y)Nz,_dispatch_key must be a torch._C.DispatchKey _dispatch_key) isinstancetorch_CrAssertionError__dict__rold_dispatch_mode_flags!old_non_infra_dispatch_mode_flags8old_without_ignore_compile_internals_dispatch_mode_flags)selfr!s r__init__zTorchDispatchMode.__init__ZsW  $mUXX-A-AB$%STT-:DMM/ *49G$>Cg. G Erct|dst|_t|dst|_t|dst|_yy)Nr'r(r))hasattrrr'r(r)r*s r"_lazy_init_old_dispatch_mode_flagsz4TorchDispatchMode._lazy_init_old_dispatch_mode_flagsfsNt678=D (t@ABG'D 2 L   I rctr)NotImplementedErrorr*functypesargskwargss r__torch_dispatch__z$TorchDispatchMode.__torch_dispatch__ts!!rc||j|jjtda|jjt t xs|j a|jjttxs|j attt||S)NT) r/r'appendrr(r is_infra_moder)rignore_compile_internalsr _push_moder.s r __enter__zTorchDispatchMode.__enter__ws //1 $$++,FG%)" ..55 0  1 L8J8J8L4L - EELL <  = 30022 9 8 <  4 rcH|jjdd}||jjdd}|jja|j ja|jjattt|y)Nr! _mode_key) r&getr'poprr(rr)rr _pop_mode)r*exc_typeexc_valexc_tbmb_dk_or_mode_keys r__exit__zTorchDispatchMode.__exit__s MM--otD  $!% 1 1+t D %)%A%A%E%E%G"  2 2 6 6 8 -  I I M M O 9 8 <  #$rcDtjdd||i|}|S)NzP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`) stacklevel)warningswarn)clsr5r6instances rpushzTorchDispatchMode.pushs* ^ ''rcy)NFrrMs rr:zTorchDispatchMode.is_infra_modesrc&|jryy)a9Ignore operators that are compiled via torch.compile. If ``True``, then this TorchDispatchMode ignores operators that are optimized by :func:`torch.compile`. Mechanically, this involves turning off the TorchDispatchMode throughout the whole compilation process, and turning it back on for the runtime of the compiled artifact(s). For example, @torch.compile def f(x): return x.sin().cos() with LoggingMode(): f(x) The above example will not log anything if ``LoggingMode.ignore_compile_internals()`` is True. torch.compile will fuse sin() and cos() into a single operation and this TorchDispatchMode will not be passed sin and cos. If ``False`` (default), :func:`torch.compile` will respect the eager semantics of passing this TorchDispatchMode all operators that would have run during eager execution. The way this will usually happen is that :func:`torch.compile` will just fallback to eager-mode PyTorch. TF)r:rQs rr;z*TorchDispatchMode.ignore_compile_internalss8    rrreturnNonerNrTbool)__name__ __module__ __qualname____doc__supports_higher_order_operatorsr+r/r7r=rG classmethodrOr:r;rrrrr5seD',#   ">%*rrc>t}|dkDrt|dz Sy)zk Return the top user mode on the stack (the next one that would be executed) if there are any. rN)r r ) stack_lens r_get_current_dispatch_moderbs% *+I1}%i!m44 rc|tjjjtjjjfvrXt dtjjjdtjjjd|ddlm}||}tjj|}| | t d||S|S)Nzkey must be either FUNCTIONAL (z) or PROXY (z1) _TorchDispatchModeKey, got r)_get_dispatch_mode_pre_dispatchzEAt most one of pre_dispatch_mode and post_dispatch_mode may be active) r#r$_TorchDispatchModeKey FUNCTIONALPROXYr% torch._opsrd_get_dispatch_mode)keyrdpre_dispatch_modepost_dispatch_modes r_detect_infra_moderms  &&11 &&,,-ehh.L.L.W.W-XY 8899??@A   ;7<44S9$);)G S   !! rcddlm}m}||}tjj |}|r |r t d|r ||}|S|rtjj|Sy)Nr)rdunset_mode_pre_dispatchzECan't have active infra mode on both pre and post dispatch mode stack)rhrdror#r$rir%_unset_dispatch_mode)rjrdrorkrlmodes r_unset_infra_moderrslS7<44S9/ S  &s+ xx,,S11rc#K|tjjjtjjjfvr t dt |} || t|yy#| t|wwxYww)Nz>> H   y%d+A  0 0 3B& &C   % &&4 rc|tjjjk(r ddlm}|S|$t |tjjr t|Sy)Nr)_pop_mode_from_pre_dispatch) r#r$rr}rhrr"rer )rrs rrBrB>sOEHH , ,,:*,,yJq%(("@"@A(++Brc#bKt|} |t|y#t|wxYwwr)rBr<)rolds r_pop_mode_temporarilyrHs' A,C 3 3s / / ,/c#Kddlm}m}ddlm}ddlm}ddlm}|}t|Dcgc] }| }}d}d} d} |D]-} t| |rd}t| |rd} t| |s,d} /t} t| Dcgc] }t} }| D]N}t||r | r tdt||r |r td t||sB| sEtd  || zt| D] }t|t|D] }t|ycc}wcc}w#t| D] }t|t|D] }t|wxYww) Nr)&_len_torch_dispatch_stack_pre_dispatchr)FunctionalTensorMode)SchemaCheckMode)ProxyTorchDispatchModeFTzFCan't have FunctionalMode available both in PreDispatch and Python KeyzNCan't have ProxyTorchDispatchMode available both in PreDispatch and Python KeyzGCan't have SchemaCheckMode available both in PreDispatch and Python Key)rhrr#torch._subclasses.functional_tensorr#torch._subclasses.schema_check_moder"torch.fx.experimental.proxy_tensorrrwr"r rBr%reversedr<)rrrrrmode_len_pre_dispatch_old_pre_dispatch_modeshas_proxy_mode_in_pre_dispatch#has_functional_mode_in_pre_dispatch%has_schema_check_mode_in_pre_dispatchrxmode_len old_modesrrqs r_disable_current_modesrQsICIBD/45J/K*+#%&+"*/',1) #9 a/ 0-1 * a- .26 / a )48 1 9)*H&+Ho66I6 s0 13 X  c1 27U `  c? +0U Y $$y00Y' D t  34 D t  U"7.Y' D t  34 D t  sG/E:D55E:5E:D:!AE:'E:* E:7D?>AE:?8E77E:ceZdZddZy)BaseTorchDispatchModeNc|i}||i|Srrr2s rr7z(BaseTorchDispatchMode.__torch_dispatch__s >FT$V$$rrV)rYrZr[r7rrrrrs%rrc:eZdZUddZe ddZded<edddZeddZedddZ edd Z dd Z dd Z e ddd  dd Z e ddd  ddZ e ddd  ddZ y)TensorWithFlattencyrrr.s r__tensor_flatten__z$TensorWithFlatten.__tensor_flatten__rcyrr) inner_tensors flatten_spec outer_size outer_strides r__tensor_unflatten__z&TensorWithFlatten.__tensor_unflatten__srz torch._C.SizeshapeNcyrrr*dims rstridezTensorWithFlatten.strides;>rcyrrrs rrzTensorWithFlatten.strides'*rcyrrrs rsizezTensorWithFlatten.sizes9NQ   >> ** << ((( #  59 !  2  =A+/" 599)   2 #  59   2  rrct|tjxrt|tju}|xrt |dxr t |dS)aW Returns whether or not a tensor subclass that implements __torch_dispatch__ is 'traceable' with torch.compile. In order for a tensor subclass to support TorchDispatchMode-style tracing in PT2, It must implement two magic methods: __tensor_flatten__ and __tensor_unflatten__. It is also expected to obey some restrictions around traceability and aliasing: * The subclass's __torch_dispatch__() implementation should desugar into pytorch dispatcher operations that can be traced into a graph. * The subclass should use return_and_correct_aliasing(). This is needed today to make sure that torch.compile does the right thing in a few cases around input mutation and output aliasing. Expected magic method signatures: attrs, ctx = t.__tensor_flatten__() attrs: list of attribute name strings for inner tensors ctx: dict containing any other subclass-specific metadata needed for unflattening t = MySubClass.__tensor_unflatten__(inner_tensors, ctx, outer_size, outer_stride) inner_tensors: dict mapping attribute name -> tensor for each inner tensor ctx: dict with subclass metadata in the form that __tensor_flatten__() produces outer_size: expected (possibly symbolic) size that the returned subclass instance should have. Note that this arg is useful for certain subclasses that require the shape info to be constructed. In most cases, this arg can be safely ignored. outer_stride: expected (possibly symbolic) stride that the returned subclass instance should have. Note that this arg is useful for certain subclasses that require the stride info to be constructed. In most cases, this arg can be safely ignored. rr)r"r#Tensortyper-)t is_subclasss ris_traceable_wrapper_subclassrsN<Q -M$q'2MK / A+ , / A- .rct|tjxr.|tjuxrt|dxr t|dS)z@Same as above, but takes a type argument instead of an instance.rr) issubclassr#rr-)rs r"is_traceable_wrapper_subclass_typersJ 1ell# / U\\ ! / A+ , / A- . rc ||n|j}||n|j}|j\}}i}|D]}||t||||<t |j ||||}|j |k7r'tdt |d|d|j |j|k7r+tdt |d|d|j|S)a Given a traceable, wrapper tensor subclass ``t`` that implements ``__torch_dispatch__`` and holds some inner tensors, and a callback of type ``Callable[[str, torch.Tensor], torch.Tensor]``, `transform_subclass` will construct a fresh instance of the wrapper tensor subclass. It will do so by grabbing each inner tensor attribute from the wrapper, passing them into ``callback`` to get a transformed tensor, and putting each transformed tensor into the fresh tensor subclass instance. Note: this function will not handle ensuring that the fresh subclass gets the same (autograd, and aliasing) metadata as the original tensor. This is generally handled in other subsystems like AOTAutograd. zExpected return value from z.__tensor_unflatten__() to have shape equal to z , but got: z/__tensor_unflatten__() to have stride equal to )rrrgetattrrrrr%) rcallbackrrattrsctxtransformed_tensors_dictattrsubs rtransform_subclassrs *51668J#/#;<L%%'JE3!J)1$48H)I &J q' & & #z< C yyJ)$q'3(\SYYK A   zz||#)$q'3+nK ~ G  Jrcvttjjst dt |t|t st dt |t|tt fst dt |dfd }|jD]\}}|||||y)a Given: an OpOverload, a SchemaInfo (cached information from torchgen about schema), and the inputs/outputs to the OpOverload, this function checks to see if func is a view operator (by checking if any of the outputs in the op's schema are immutable aliases of inputs). If so, this function manually aliases the storage of the output tensor with its corresponding input tensor alias. It does this by unsafely overwriting the storage field of the output tensor to be the same storage as the input. z func must be an OpOverload, got zargs must be a tuple, got z"outs must be a list or tuple, got c t|}t|}||urxt|s t|rbt|tr|n|g}|D]H}t|t|ust dt dt|dt|dt|tr|D]}t j||yt|t jst dt|t j||y)NzCalled z with input of type z and output of type z. But expected types to match.zexpected torch.Tensor, got ) rrr"listr%strr#_functionalize_unsafe_setr)argretarg_typeret_typeret_listrr3s ralias_non_inplace_storagez<_correct_storage_aliasing..alias_non_inplace_storage=s99 8 # .x 81(;(d3s#H 9DG+(!#d),@c L..23i[8VX " c4  8//37 8c5<<0$'B49+%NOO  + +C 5rNrS) r"r#_ops OpOverloadr%rtuplerread_only_alias_match_indexes)r3 schema_infor5outsrarg_idx return_idxs` r_correct_storage_aliasingr*s dEJJ11 2?T |LMM dE "9$t*FGG dT5M *A$t*NOO)6V +HHC!$w-j1ABCrc|j}|r |jsyt|dk7r tdt t |S)Nr`z1Expected alias_set to contain exactly one element) alias_setis_writelenr%nextiter)xrs r_get_write_aliasrls@ I AJJ 9~PQQ Y  rc,eZdZUded<ded<ded<y) AliasInfozset[str]rrXr str | NonenameNrYrZr[rrrrrr{sN rrc@eZdZUded<ded<ded<ded<ded <y ) SchemaInfozlist[AliasInfo]r5rrXis_inplace_view_opzlist[str] | Noneouts_write_aliaseszlist[tuple[int, int]]rNrrrrrrs$   )($98rrc$|jdk(rt|j}|jds t d|dd}ddl}|j dd|}|j dd |}|j d d |}tjjj|}|jjDcgc]q}t|j tnt|jj |jduxr|jj"|j$ s}}|j&Dcgc]q}t|j tnt|jj |jduxr|jj"|j$ s}}n |jjDcgc]q}t|j( tnt|j(j*|j(duxr|j(j"|j$ s}}|jj&Dcgc]q}t|j( tnt|j(j*|j(duxr|j(j"|j$ s}}g}t-|D]V\}} t-|D]C\} } | j | j zxr | j" } | s1|j/|| fEX|D cgc] } t1| }} t3d |D}|dk(rd}nF|t5|k7r!t7dt|jzt9t:t|}t=||t>j@jB|jDv||}|Scc}wcc}wcc}wcc}wcc} w)Natenzaten::z6Expected torchgen schema string to start with 'aten::'rz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=\[(-?[0-9]+), (-?[0-9]+)\]z=[\1,\2])rrrc3$K|]}|du ywrr).0rs r z!get_alias_info..sCaATMCszUnsupported schema: )r5rrrr)# namespacer_schema startswithr%rertorchgenmodelFunctionSchemaparse argumentsflat_allr annotationsetrrrreturns alias_info before_set enumerater9rsumr RuntimeErrorrrrr#Tag inplace_viewtags)r3torchgen_schema_strrtorchgen_schemaa arg_schemas out_schemasrr schema_argr schema_outis_read_only_alias_matchrouts_write_aliases_list non_nonesrrs rget_alias_infor!s ~~!$,,/"--h7 H  2!"5!ff^T;NO ff^T;NO ff *K9L #..77==>QR%..77   \\1CEs1<<;Q;Q7RT1Kall6K6KVV     $%,,   \\1CEs1<<;Q;Q7RT1Kall6K6KVV     (\\++   \\1CEs1<<;R;R7ST1Kall6K6KVV     $\\))   \\1CEs1<<;R;R7ST1Kall6K6KVV     %'!(5L&/ &< L "J $$z';';;(* ))) %(-44gz5JK  LL&11 !11C+BCCIA~/3 c12 21C 4EEFF!$s)-DE  !9911TYY>-&CK Q        &1s"A6O9 A6O>A6P-A6PP cZd}|D]}t|tjstjj tjj |j j}|Jtjj|j|}| S| S)aN Suppose that an operator has CompositeImplicitAutograd decomp registered. Would autograd have used this decomposition? It will only use it if there isn't an explicit backend registration for the device as well. This function will tell if this would have occurred. Why do we need to apply these decompositions later? When inference mode is on, the autograd key is bypassed entirely, so a lower level mode cannot rely on the decomposition have been applied. It's easy to accidentally never apply the decomposition, resulting in an operator showing up in a graph that is unexpected. Why do we need to AVOID applying the decomposition when autograd wouldn't have decomposed? If autograd doesn't decompose, this means in eager mode we would have run the fused kernel. It must be possible to trace this fused kernel directly into the graph for fidelity with eager (NB: a user has the option of then further decomposing at proxy tensor mode via decomposition table, but we must preserve it to proxy mode to have the choice.) Why does functionalization need to also perform the test here? This is because some CompositeImplicitAutograd decompositions are not functional. If we are eventually going to decompose, we need to do this while we can still turn functionalization back on, so those decompositions get functionalized. So an early decomposition in functionalization may still be necessary. Note that if proxy tensor decomposition process could turn functionalization back on, this wouldn't be necessary, and maybe that is a useful thing to do anyway because the decomposition table is user specified and a user could violate the functional decomp requirement with a bad decomp. If this happened, then you could always pass through functionalization. F) r"r#rr$_parse_dispatch_key_dispatch_key_for_devicerr%_dispatch_has_kernel_for_dispatch_keyr)r3 flat_argshas_backend_registrationr backend_keys rautograd_would_have_decomposedr)sD %  a &((6611!((--@K* **(-xx'U'U [( $ ' ''#"( ''rc t}fd}t||t|ts|fn||jrt |Dcgc]\}}t |j||!}}}t|dk7r tdddl m } t|d| stjjj5tj j#} tj j%d |i|tj j%|  ddd|j&} | |St| dk(r|| d|||St)|| D cgc] } || |||c} } | Scc}}w#tj j%| wxYw#1swYxYwcc} w)aZ This function should be used by wrapper tensor ``__torch_dispatch__`` subclasses that would like to work with torch.compile. It ensures that the subclass properly implements the aliasing behavior of every op, which is needed for correctness in AOTAutograd. This function will handle: * When we see a view op, we will alias the storages of any input and output tensor subclasses * When we see an inplace or out= op, we will directly return the corresponding input tensor, instead of returning a (potentially) fresh output tensor. ctjjj ||\}}t |j Dcgc]\}}||j vs|}}}t|dk7r td|d} |j | } | j| j|vr|| jS|| Scc}}w)N)r5r6r`z>Expected exactly one argument index for the given output aliasr) r#fxoperator_schemasnormalize_functionrr5rrr%r) output_aliasrr5r6new_args new_kwargsrxr arg_indicesidxarg_infor3s rget_arg_from_aliasz7return_and_correct_aliasing..get_arg_from_aliasCs$xx88KK tF L * $K$4$45 !Q9TA   { q  P !n##C( == $*)Dhmm, ,} s C CNr`z5expected exactly one mutated arg for inplace_view opsr)FunctionalTensorT)r!rr"rrrrr5rr%rr6r#utils _mode_utils no_dispatchr$_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includerr)r3r5r6outrr5rxr mutated_argsr6 meta_in_tlsschema_info_outs_write_aliases write_aliasouts_to_returns` rreturn_and_correct_aliasingrB/s$!&K* k4z#u/E#3 %% "$ 1 0 0 34@    |  ! G  I,q/+;<((446 L$hhDDF ::4@L$)&)HH>>{K L&1%C%C"%-  )*a/! *1 -{D&  T#Y >  [$ G N ] 2HH>>{K L L0 s0 $F >F9 FF94G!F66F99G)T)rrXrTrXrW)rTzTorchDispatchMode | None)rTzlist[TorchDispatchMode])rqrrTrUr)rz3DispatchKey | torch._C._TorchDispatchModeKey | None)rzDispatchKey | None)robjectrTzTypeIs[TensorWithFlatten])rrrTzTypeIs[type[TensorWithFlatten]])NNrS)rTr)rTr)r3ztorch._ops.OpOverloadr&zSequence[torch.Tensor | object]rTrX): __future__r contextlib functoolsrK collectionsr dataclassesrtypingrrrr typing_extensionsr r#rtorchgen.modeltorch._Cr r r rrtorch._C._dynamo.guardsrcollections.abcrrrrrrrrbrmrrruryr<rBcontextmanagerrrrrrrrrrrrcacher!r)rBrrrrQsm"!::$ T(#',$380<aaH42" # A!*,  55p%-%;;|#L'T?CD !     9 9  9$ __D4( 4(,K4( 4(n`r