˲j=rUddlZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZddlmZddlmZddlZddlZddlZddlmZmZmZmZmZdadad(d e fd Z!Gd d Z"d Z#dZ$dZ%dZ&dZ'de"fdZ(d)dee eej)j*ffdZ+ej,d)deefdZ-ej,dZ.Gdde"Z/Gdde Z0de1d ee0fdZ2ded eee0fdZ3d*dZ4d Z5eGd!d"Z6eGd#d$Z7iZ8eee7fe9d%<d e7fd&Z:d'Z;dS)+N) dataclass) AnyDictListOptionalSetUnionProtocolTupleSequenceoverloadDequeType)TypeIs)deque)_get_dispatch_stack_at_len_torch_dispatch_stack_pop_torch_dispatch_stack_push_on_torch_dispatch_stack DispatchKeyFTreturnc"|rtntSN)_is_in_torch_dispatch_mode$_is_in_non_infra_torch_dispatch_mode)include_infra_modess MC:\Projects\Historical\venv\Lib\site-packages\torch/utils/_python_dispatch.pyis_in_torch_dispatch_moders)< f % %Bffc`eZdZdZd dZdZd dZdZdZe d Z e d Z dS) 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|+t|tjjsJ||jd<t |_t |_dS)N _dispatch_key) isinstancetorch_Cr__dict__rold_dispatch_mode_flags!old_non_infra_dispatch_mode_flags)selfr#s r__init__zTorchDispatchMode.__init__BsM  $mUX-ABB B BB-:DM/ *49GG$>Cgg...rct|dst|_t|dst|_dSdS)Nr(r))hasattrrr(r)r*s r"_lazy_init_old_dispatch_mode_flagsz4TorchDispatchMode._lazy_init_old_dispatch_mode_flagsJsTt677 @8=D (t@AA JBG''D 2 2 2 J Jrctr)NotImplementedErrorr*functypesargskwargss r__torch_dispatch__z$TorchDispatchMode.__torch_dispatch__Rs!!rc||jtda|jt t p| at||S)NT)r/r(appendrr)r is_infra_mode _push_moder.s r __enter__zTorchDispatchMode.__enter__Usz //111 $++,FGGG%)" .556Z[[[/S/o[_[m[m[o[oWo,4 rc|jdd}||jdd}|ja|jat|dS)Nr# _mode_key)r'getr(poprr)r _pop_mode)r*exc_typeexc_valexc_tbmb_dk_or_mode_keys r__exit__zTorchDispatchMode.__exit__dsy M--otDD  $!% 1 1+t D D %)%A%E%E%G%G"/3/U/Y/Y/[/[,#$$$$$rc>tjd||i|}|S)NzP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`)warningswarn)clsr6r7instances rpushzTorchDispatchMode.pushps4 ^   3'''rcdS)NFr0)rKs rr;zTorchDispatchMode.is_infra_modexsurrr0N) __name__ __module__ __qualname____doc__r+r/r8r=rG classmethodrMr;r0rrr!r!#s<FFFFJJJ""""    % % %[[rr!cRt}|dkrt|dz SdSNr)rr stack_lens r_get_current_dispatch_moderZ~s-)++I1}}%i!m444 4rc|tjjjtjjjfvsJddlm}||}tj|}||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_moderes 581\>bc c c c c::::::77 44   %""  !! rcddlm}m}||}tj|}|r|rt d|r ||}|S|rtj|SdS)Nr)r\unset_mode_pre_dispatchzECan't have active infra mode on both pre and post dispatch mode stack)r`r\rgr%r&raAssertionError_unset_dispatch_mode)rbr\rgrcrdmodes r_unset_infra_moderksSSSSSSSS77<<44S99 /  S   &&s++ 2x,,S11122rc#K|tjjjtjjjfvsJt |} |V|t |dSdS#|t |wwxYwr)r%r&r]r^r_rkr<)rb mode_unsets r_disable_infra_moderns  &1 &,    #3''J#  ! z " " " " " " !: ! z " " " " "s AA0cPt}dt|DS)Nc,g|]}t|Sr0)r).0is r z4_get_current_dispatch_mode_stack..s! @ @ @! "1 % % @ @ @r)rrangerXs r _get_current_dispatch_mode_stackrus))++I @ @uY/?/? @ @ @@rrjcLt|dr|jnd}||tjjjksJ|t |dSddlm}m }tj |}|D]}|D]}| |||dS)Nr#r)_set_mode_pre_dispatchget_cached_ops) r-r#r%r&r PreDispatchrr`rwrx_functionality_to_backend_keys_uncache_dispatch)rjkrwrxksoprbs rr<r<s%dO<<F$A 9UX1==== =y%d+++AAAAAAAA  0 0 3 3Bn&& & &C   % % % % &4     rr|c|tjjjkrddlm}|S|t |tjjrt|SdS)Nr)_pop_mode_from_pre_dispatch) r%r&rryr`rr$r]r)r|rs rrBrBscEH ,,,::::::**,,,yJq%("@AAy(+++yrc#xKt|} |Vt|dS#t|wxYwr)rBr<)r|olds r_pop_mode_temporarilyrs> A,,C 3 3s(9c#LKddlm}mddlm}ddlm}ddlm}|}fdt|D}d}d}d}|D]8} t| |rd}t| |rd}t| |rd}9t} d t| D} | D]e} t| |r|rtd t| |r|rtd t| |r|rtd f || zVt| D]} t| t|D]} t| dS#t| D]} t| t|D]} t| wxYw) Nr)&_len_torch_dispatch_stack_pre_dispatchr)FunctionalTensorMode)ProxyTorchDispatchMode)SchemaCheckModec$g|] } Sr0r0)rq_rs rrsz*_disable_current_modes..s0*+##%%rFTc*g|]}tSr0)rB)rqrs rrsz*_disable_current_modes..s666666rzFCan'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_moderrtr$rrhreversedr<)rrrrmode_len_pre_dispatchold_pre_dispatch_modeshas_proxy_mode_in_pre_dispatch#has_functional_mode_in_pre_dispatch%has_schema_check_mode_in_pre_dispatchrrmode_len old_modesrrjrs @r_disable_current_modesrsIHHHHHIIIIIICCCCCCBBDD/45J/K/K&+"*/',1) #99 a/ 0 0 2-1 * a- . . 726 / a ) ) 948 1(**H66eHoo666I s0 1 1 3 !X  c1 2 2 7U  `  sO , , 5 !Y  $y0000Y''  D t    344  D t      Y''  D t    344  D t     s EAF#ceZdZddZdS)BaseTorchDispatchModer0Nc|i}||i|Srr0r3s rr8z(BaseTorchDispatchMode.__torch_dispatch__ s! >FtT$V$$$rrO)rPrQrRr8r0rrrrs(%%%%%%rrceZdZUdeeeeffdZede de de de de j f dZ e j jed<edd d dee d ffd Zed e de fd Zedd d dee d ffdZed e de fdZde fdZde fdZe dd dde jjdededee jde j f dZe d d ddeddee jjdededee jde j f dZe dd dde j dededee jde j f dZd S)!TensorWithFlattenrcdSrr0r.s r__tensor_flatten__z$TensorWithFlatten.__tensor_flatten__( r inner_tensors flatten_spec outer_size outer_stridecdSrr0)rrrrs r__tensor_unflatten__z&TensorWithFlatten.__tensor_unflatten__+ rshapeNdim.cdSrr0r*rs rstridezTensorWithFlatten.stride5rrcdSrr0rs rrzTensorWithFlatten.stride9rrcdSrr0rs rsizezTensorWithFlatten.size=rrcdSrr0rs rrzTensorWithFlatten.sizeArrcdSrr0r.s rstorage_offsetz TensorWithFlatten.storage_offsetErrcdSrr0r.s rrzTensorWithFlatten.dimHrrF) memory_formatdtype non_blockingcopyrcdSrr0)r*rrrrs rtozTensorWithFlatten.toK  rdevicez"torch._prims_common.DeviceLikeTypecdSrr0)r*rrrrrs rrzTensorWithFlatten.toVs  rothercdSrr0)r*rrrrs rrzTensorWithFlatten.tobrrr)FF)NNFF)rPrQrRr r strobjectr staticmethodintr%Tensorrr&Size__annotations__r rrrrr5_dtypeboolrrrr0rrrr's. E(3-*?$@     C s PS cf kpkw   \  8=   $ %S/   X  # #   X    c3h   X      X       S    "'  <@    ;%    $E$78      X FJ26!&  <@    AB  EK./      $E$78       X  "'  <@    <    $E$78      X   rrtct|tjot|tjk}|ot |dot |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_subclassrpsU<Q --I$q''U\2IK / A+ , , / A- . .rct|tjo/|tjkot|dot|dS)z@Same as above, but takes a type argument instead of an instance.rr) issubclassr%rr-)rs r"is_traceable_wrapper_subclass_typersN q%, ' ' XA,= X/00 X5.alias_non_inplace_storagesc ) - - @1Ns1S1S @(d33>ss#H @ @CyyD%%@s4yy@@d3ii@@II@@@ c4  6 8 8/37777 8 8c5<00 F F2F4992F2F F F0  +C 5 5 5 5 5rcV|j|jz}t|dko|j S)Nr) alias_setlenis_write)rrshared_aliasess ris_read_only_alias_matchz;_correct_storage_aliasing..is_read_only_alias_matchs-6>""Q&;s|+;;rN) r$r%_ops OpOverloadtuplerr_schema argumentsreturnsrtr6outs) r4 schema_infor6rrrnum_args num_returnsarg_idx return_idxs ` r_correct_storage_aliasingrs+ dEJ1 2 222 2 dE " """ " dT5M * *** *66666@<<<4<)**Hdl*++K??KK ,, K KJ'' );+;J+G K*)$w-j9IJJJ  KKKrcFeZdZUeeed<eed<eeed<dS) AliasInforrnameN)rPrQrRrrrrrr0rrrrs;3xNNN 3-rrc<eZdZUeeed<eeed<dS) SchemaInfor6rN)rPrQrRrrrr0rrrr s2 y/ y/rrparsed_schema_mapcj|tvr t|S|jdkrt|j}|dsJ|dd}ddl}|dd|}|dd|}|d d |}tjj |}d |j j D}d |j D}n,d |jj D}d|jj D}t||}|t|<|S)Natenzaten::rz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=\[(-?[0-9]+), (-?[0-9]+)\]z=[\1,\2]cg|]X}t|jtnt|jj|jduo |jj|jYSN)rrrr annotationsetrrrrqas rrsz"get_alias_info..+q     \1CEEEs1<;Q7R7RT1Kal6KV        rcg|]X}t|jtnt|jj|jduo |jj|jYSrrrs rrsz"get_alias_info..5rrcg|]X}t|jtnt|jj|jduo |jj|jYSrr alias_infor before_setrrrs rrsz"get_alias_info..Aq     \1CEEEs1<;R7S7ST1Kal6KV        rcg|]X}t|jtnt|jj|jduo |jj|jYSrrrs rrsz"get_alias_info..Kr r)r6r)r namespacerr startswithrertorchgenmodelFunctionSchemaparserflat_allrr)r4torchgen_schema_strrtorchgen_schema arg_schemas out_schemasrs rget_alias_infors     && ~!$,//"--h777772!""5 !ff^T;NOO ff^T;NOO ff%C[Reff".7==>QRR   %.7       %,       \+       \)    +K@@@K)d rc  t d fdt t|ts|fn|tjjjvr fdtD}t|dksJddl m }t|d|stj j 5tj}tjd itj|n$#tj|wxYw dddn #1swxYwYt% fd  jDs|St) fd  jDs$t+d t-jztjjdkr" jd St3|  fd t5t j|D}|S) 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|jdkrdSt|j}t|dksJ|jr|dSdSrV)rrrr)xrs rget_write_aliasz4return_and_correct_aliasing..get_write_aliasns[ q{  q 4%% 9~~"""" : Q< trc8tjj ||\}}fdt |jD}t |dksJ|d}|j|}|j|j|vr ||jS||S)N)r6r7c,g|]\}}|jv|Sr0)r)rqrrr output_aliass rrszKreturn_and_correct_aliasing..get_arg_from_alias..}s0   !Q9T9TA9T9T9TrrWr)r%fxoperator_schemasnormalize_function enumerater6rr) rrr6r7new_args new_kwargs arg_indicesidxarg_infor4s ` rget_arg_from_aliasz7return_and_correct_aliasing..get_arg_from_aliasxs$x8KK tF L  *    #K$455   ;1$$$$!n#C( = $*)D)Dhm, ,}rcFg|]\}}j||Sr)r6)rqrrrrrs rrsz/return_and_correct_aliasing..s?   1{/233? ???rrWr)FunctionalTensorTNc32K|]}|duVdSrr0rqrrs r z.return_and_correct_aliasing..2HH!q!!-HHHHHHrc32K|]}|duVdSrr0r-s rr.z.return_and_correct_aliasing..r/rzUnsupported schema: czg|]7\\}}}|"j|n|8Sr)r) rqrrror6r)rr7rs rrsz/return_and_correct_aliasing..sw !Q#?1%%1#"#OK$4Q$788+tV r)rrr$rr%Tag inplace_viewtagsr#rrr+utils _mode_utils no_dispatchr&_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includeanyrall RuntimeErrorrrrrzip) r4r6r7out mutated_argsr+ meta_in_tlsouts_to_returnr)rrs ``` @@@rreturn_and_correct_aliasingrCZs-$!&&K$ k4z#u/E/E!N#3  y**     !$   <  A%%%% IHHHHH,q/+;<< L(4466 L L$hDDFF ::4@@@LD$)&)))H>>{KKKKEH>>{KKKKK L L L L L L L L L L L L L L L HHHH{7GHHH H H  HHHH{7GHHH H HG1C 4E4EEFFF 4<   A%%!! OK,Q/ 0 0+tV   T#YY  #9[-=#>#>DD   N s*>E)D8 E)8!EE))E-0E-)Tr)NN)< contextlibrI dataclassesrtypingrrrrrr r r r r rrtyping_extensionsr collectionsrr%rtorchgen.modeltorch._Crrrrrrrrrr!rZrerkrnrur<r&r]rBcontextmanagerrrrrrrrrrrrrrrrCr0rrrLs!!!!!!jjjjjjjjjjjjjjjjjjjjjjjjjjjj$$$$$$ #',$gg4ggggWWWWWWWWv*222" # # #AAA !&!!!!$,,% UX-K KLM,,,, Xk2 888v%%%%%-%%%D D D D D D D D R#V#7H0I####JY$Y6$?P:Q3RYYYY %%%%P;K;K;KB      ,.4Z(--- @J@@@@Fmmmmmr