DŽgnhUddlZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZddlmZddlmZddlZddlZddlZddlmZmZmZmZmZdadad'de fd Z!Gd d Z"d Z#d Z$dZ%dZ&dZ'de"fdZ(d(dee eejRjTffdZ+ejXd(deefdZ-ejXdZ.Gdde"Z/Gdde Z0de1dee0fdZ2dedeee0fdZ3d)dZ4dZ5eGd d!Z6eGd"d#Z7iZ8eee7fe9d$<de7fd%Z:d&Z;y)*N) dataclass) AnyDictListOptionalSetUnionProtocolTupleSequenceoverloadDequeType) TypeGuard)deque)_get_dispatch_stack_at_len_torch_dispatch_stack_pop_torch_dispatch_stack_push_on_torch_dispatch_stack DispatchKeyFreturnc|rtStSN)_is_in_torch_dispatch_mode$_is_in_non_infra_torch_dispatch_mode)include_infra_modess d/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/utils/_python_dispatch.pyis_in_torch_dispatch_moders)< %fBffcReZdZdZd dZdZd dZdZdZe dZ e d 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 ``__torch_dispatch__(self)`` to make PyTorch API self-referential (beware of infinite loops, in this case!) Nc|5t|tjjsJ||jd<t |_t |_y)N _dispatch_key) isinstancetorch_Cr__dict__rold_dispatch_mode_flags!old_non_infra_dispatch_mode_flags)selfr#s r__init__zTorchDispatchMode.__init__BsD  $mUXX-A-AB BB-:DMM/ *49G$>Cg.rcrt|dst|_t|dst|_yy)Nr(r))hasattrrr(r)r*s r"_lazy_init_old_dispatch_mode_flagsz4TorchDispatchMode._lazy_init_old_dispatch_mode_flagsJs2t678=D (t@ABG'D 2Brctr)NotImplementedErrorr*functypesargskwargss r__torch_dispatch__z$TorchDispatchMode.__torch_dispatch__Rs!!rc|j|jjtda|jjt t xs|j at||S)NT)r/r(appendrr)r is_infra_mode _push_moder.s r __enter__zTorchDispatchMode.__enter__Use //1 $$++,FG%)" ..556Z[/S/o[_[m[m[oWo,4 rc|jjdd}||jjdd}|jja|j jat|y)Nr# _mode_key)r'getr(poprr)r _pop_mode)r*exc_typeexc_valexc_tbmb_dk_or_mode_keys r__exit__zTorchDispatchMode.__exit__dsk MM--otD  $!% 1 1+t D %)%A%A%E%E%G"/3/U/U/Y/Y/[,#$rc@tjd||i|}|S)NzP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`)warningswarn)clsr5r6instances rpushzTorchDispatchMode.pushps' ^ ''rcy)NF)rJs rr:zTorchDispatchMode.is_infra_modexsrrrNN) __name__ __module__ __qualname____doc__r+r/r7r<rF classmethodrLr:rNrrr!r!#sJ<FJ"  %rr!c>t}|dkDrt|dz SyNr)rr) stack_lens r_get_current_dispatch_moderY~s#)+I1}%i!m44 rc |tjjjtjjjfvsJddlm}||}tjj|}||J||S|S)Nr)_get_dispatch_mode_pre_dispatch)r%r&_TorchDispatchModeKey FUNCTIONALPROXY torch._opsr[_get_dispatch_mode)keyr[pre_dispatch_modepost_dispatch_modes r_detect_infra_moderds 58811<\>\>b>bc cc c:7 44   %"  !! rcddlm}m}||}tjj |}|r |r t d|r ||}|S|rtjj|Sy)Nr)r[unset_mode_pre_dispatchzECan't have active infra mode on both pre and post dispatch mode stack)r_r[rfr%r&r`AssertionError_unset_dispatch_mode)rar[rfrbrcmodes r_unset_infra_moderjslS7<44S9/ S  &s+ xx,,S11rc#K|tjjjtjjjfvsJt |} || t |yy#| t |wwxYwwr)r%r&r\r]r^rjr;)ra mode_unsets r_disable_infra_moderms  &&11 &&,,  #3'J#  ! z " ": ! z " "sABA.B.A>>Bcdt}t|Dcgc] }t|c}Scc}wr)rranger)rXis r _get_current_dispatch_mode_stackrqs))+I/4Y/? @! "1 % @@ @s-ricPt|dr |jnd}|)|tjjj k(sJ| t |yddlm}m }tjj|}|D]}|D]}|j|||y)Nr#r)_set_mode_pre_dispatchget_cached_ops) r-r#r%r&r PreDispatchrr_rsrt_functionality_to_backend_keys_uncache_dispatch)rikrsrtksopras rr;r;s%dO<$A 9UXX11==== =y%d+A  0 0 3B& &C   % &&4 rrxc|tjjjk(r ddlm}|S|$t |tjjr t|Sy)Nr)_pop_mode_from_pre_dispatch) r%r&rrur_r|r$r\r)rxr|s rrArAsOEHH , ,,:*,,yJq%(("@"@A(++Brc#bKt|} |t|y#t|wxYwwr)rAr;)rxolds r_pop_mode_temporarilyrs' 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)ProxyTorchDispatchMode)SchemaCheckModeFTzFCan'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)r_rr|#torch._subclasses.functional_tensorr"torch.fx.experimental.proxy_tensorr#torch._subclasses.schema_check_moderror$rrArgreversedr;)rr|rrrmode_len_pre_dispatch_old_pre_dispatch_modeshas_proxy_mode_in_pre_dispatch#has_functional_mode_in_pre_dispatch%has_schema_check_mode_in_pre_dispatchrpmode_len old_modesr~ris r_disable_current_modesrsIICBD/45J/K*+#%&+"*/',1) #9 a/ 0-1 * a- .26 / a )48 1 9)*H&+Ho66I6 s0 13 X  c1 27U `  sO ,5 Y !*$y00Y' D t  34 D t  ["74Y' D t  34 D t  sG/E:D55E:5E:D:!AE:'E:* E:7D?>AE:?8E77E:ceZdZddZy)BaseTorchDispatchModeNc|i}||i|SrrNr2s rr7z(BaseTorchDispatchMode.__torch_dispatch__ s >FT$V$$rrO)rPrQrRr7rNrrrrs%rrczeZdZUdeeeeffdZede de de de de jf dZ e jjed<edd d dee d ffd Zed e de fd Zde fdZe dd dde j&j(dededee j.de jf dZe dd ddeddee j&j(dededee j.de jf dZe dd dde jdededee j.de jf dZy )TensorWithFlattenrcyrrNr.s r__tensor_flatten__z$TensorWithFlatten.__tensor_flatten__( r inner_tensors flatten_spec outer_size outer_stridecyrrN)rrrrs r__tensor_unflatten__z&TensorWithFlatten.__tensor_unflatten__+ rshapeNdim.cyrrNr*rs rstridezTensorWithFlatten.stride5rrcyrrNrs rrzTensorWithFlatten.stride9rrcyrrNr.s rrzTensorWithFlatten.dim=rr) memory_formatdtype non_blockingcopyrcyrrN)r*rrrrs rtozTensorWithFlatten.to@ rdevicez"torch._prims_common.DeviceLikeTypecyrrN)r*rrrrrs rrzTensorWithFlatten.toKs rothercyrrN)r*rrrrs rrzTensorWithFlatten.toWrrr)FF)NNFF)rPrQrRr r strobjectr staticmethodintr%Tensorrr&Size__annotations__r rrr4_dtypeboolrrrrNrrrr's) E(3-*?$@  C s PS cf kpkwkw   88==  $ %S/   # #   S "'  <@  ;;%%    $E$7$78     FJ26!&  <@  AB  EKK../      $E$7$78       "'  <@  <<    $E$7$78     rrtct|tjxrt|tjk7}|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%rtyper-)r is_subclasss ris_traceable_wrapper_subclassresN<Q -I$q'U\\2IK / A+ , / A- .rct|tjxr/|tjk7xrt|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_typersI q%,, ' XA,= X/0 X5 C ' Jrc*ttjjsJt|tsJt|t tfsJtj jj|}fd}d}tjj}tjj}t|D]E} t|D]5} ||j| |j| s'||| || 7Gy)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. c t|s t|r_t|tr|n|g}|D]E}t|t|k(rJdt dt|dt|dt|tr|D]}t j ||yt|t jsJdt|t j ||y)NzCalled z with input of type z and output of type z. But expected types to match.ztype: )rr$listrrr%_functionalize_unsafe_setr)argretret_listrr3s ralias_non_inplace_storagez<_correct_storage_aliasing..alias_non_inplace_storages ) -1Ns1S(d3s#H @CyD%@s4yk)=d3i[II;<@@ @ c4  8//37 8c5<<0 FF49+2F F0  + +C 5rcn|j|jz}t|dkDxr |j S)Nr) alias_setlenis_write)rrshared_aliasess ris_read_only_alias_matchz;_correct_storage_aliasing..is_read_only_alias_matchs06>"Q&;s||+;;rN)r$r%_ops OpOverloadtuplerutils_pytree tree_leavesr_schema argumentsreturnsror5outs) r3 schema_infor5r flat_outsrrnum_args num_returnsarg_idx return_idxs ` r_correct_storage_aliasingrs dEJJ11 22 2 dE "" " dT5M ** * ##//5I6@<4<<))*Hdll**+K?K , KJ'  );+;+;J+G*$w-j9IJ  KKrc8eZdZUeeed<eed<eeed<y) AliasInforrnameN)rPrQrRrrrrrrNrrrrs3xN 3-rrc.eZdZUeeed<eeed<y) SchemaInfor5rN)rPrQrRrrrrNrrrrs y/ y/rrparsed_schema_mapc0|tvr t|S|jdk(rt|j}|j dsJ|dd}ddl}|j dd|}|j dd|}|jd d }tjjj|}|jjDcgc]q}t|j t!nt!|jj"|jduxr|jj$|j& s}}|j(Dcgc]q}t|j t!nt!|jj"|jduxr|jj$|j& s}}n |jjDcgc]q}t|j* t!nt!|j*j,|j*duxr|j*j$|j& s}}|jj(Dcgc]q}t|j* t!nt!|j*j,|j*duxr|j*j$|j& s}}t/|| }|t|<|Scc}wcc}wcc}wcc}w) Natenzaten::rz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=[0, 1]z=[0,1])rrr)r5r)r namespacerr startswithrerreplacetorchgenmodelFunctionSchemaparserflat_allr annotationsetrrrr alias_info before_setr)r3torchgen_schema_strrtorchgen_schemaa arg_schemas out_schemasrs rget_alias_infor  s    && ~~!$,,/"--h7772!"5!ff^T;NO ff^T;NO199)XN"..77==>QR%..77   \\1CEs1<<;Q;Q7RT1Kall6K6KVV     $%,,   \\1CEs1<<;Q;Q7RT1Kall6K6KVV     (\\++   \\1CEs1<<;R;R7ST1Kall6K6KVV     $\\))   \\1CEs1<<;R;R7ST1Kall6K6KVV     +K@K)d Y        s A6LA6L $A6L4A6Lc ,t}dfd}t||t|ts|fn|tj j jvrt|Dcgc]\}}|j||}}}t|dk(sJddl m } t|d| stjjj5tj j#} tj j%d |i|tj j%|  dddt'fd|j(Ds|St+fd |j(Ds!t-d t/j0ztj0j2dk(r||j(d|||St5|t7t|j(|D cgc]0\\}} } | ||j(||||n| 2c} } }} | Scc}}w#tj j%| wxYw#1swYAxYwcc} } }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. ct|jdk(ryt|j}t|dk(sJ|jr|dSyrV)rrrr)xrs rget_write_aliasz4return_and_correct_aliasing..get_write_aliasdsJ q{{ q % 9~""" ::Q< rc~tjjj ||\}}t |j Dcgc]\}}||j vs|}}}t|dk(sJ|d} |j | } | j| j|vr|| jS|| Scc}}w)N)r5r6rWr) r%fxoperator_schemasnormalize_function enumerater5rrr) output_aliasrr5r6new_args new_kwargsrpr arg_indicesidxarg_infor3s rget_arg_from_aliasz7return_and_correct_aliasing..get_arg_from_aliasns$xx88KK tF L * $K$4$45 !Q9TA  ;1$$$!n##C( == $*)Dhmm, ,} s B9 B9NrWr)FunctionalTensorTc32K|]}|duywrrN.0rr s r z.return_and_correct_aliasing..H!q!-Hc32K|]}|duywrrNrs rrz.return_and_correct_aliasing..rr zUnsupported schema: )r rr$rr%Tag inplace_viewtagsrr5rrrr _mode_utils no_dispatchr&_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includeanyrall RuntimeErrorrrrrzip)r3r5r6outrrrpr  mutated_argsr meta_in_tlsroouts_to_returnr s` @rreturn_and_correct_aliasingr2Psb$!&K$ k4z#u/E#3  yy* "$ 1{//23?   < A%%% I,q/+;<((446 L$hhDDF ::4@L$)&)HH>>{K L H{7G7GH H  H{7G7GH H1C 4EEFF 4<<   A%! K,,Q/ 0+tV  T#Y #9[-=-=#>D !Q#1%1##K$4$4Q$78+tV   N i ,HH>>{K L L6 s0+!I>JI#J5J !I??JJ )Tr)NN)< contextlibrH dataclassesrtypingrrrrrr r r r r rrtyping_extensionsr collectionsrr%rtorchgen.modeltorch._Crrrrrrrrrr!rYrdrjrmrqr;r&r\rAcontextmanagerrrrrrrrrrrrrrr r2rNrrr;s!jjjj' #',$g4gWWv*2" #A !&!$,% UXX-K-K KLM, Xk2 88v%-%9 9 |#V# :K0L#JY$Y9TBS=T3UY %P<KD      ,.4Z(- @J@Fmr