iY ddlZddlZddlZddlmZmZmZddlmZm Z m Z m Z m Z ddl Z ddlmcmZddlZddl mZmZddlmZej.GddZGdd Zd ed efd Zd ed eeeffdZd ed efdZded e fdZ!dddede d e fdZ"ded e fdZ#ded e fdZ$defdZ%dZ&dejNdeedfde(eefd eeejReffdZ*d Z+ded e fd!Z,d e fd"Z-d#Z.dejNfd$Z/dejNfd%Z0dejNd e fd&Z1dejNd e edffd'Z2 d>deede(eefd(ed ee jffd)Z4d*fd+Z5d,fd-Z6Gd.d/Z7d0e jfd e jffd1Z8de jrj,d e fd2Z:dejNd ee;ee;effd3Z2sR ^^D !F 6{a**248 9  !9fQi rct|\}}d|vr|jd\}}nd}ttj|}t||}t||S)N.default)r>r:getattrtorchops)r6 namespacenamer nspackets r lookup_oprI>sV%h/OIt d{Ch I &B R F 68 $$ropclt|tstdt||jdvS)Nop must be OpOverload, got >atenprimprims) isinstancer AssertionErrortyperE)rJs r is_builtinrSIs3 b* %:48*EFF <<4 44rF)allow_valid_viewschemarTc fd}t|tjjr||Sddlm}t|t r|j |}t||stdt|||S)afCheck if the schema is functional. An operator is functional if: - it does not mutate any of its inputs - If no view are allowed - it does not return a view on any of its inputs - If valid views are allowed - it is not a view or a view with a single input Tensor and single output Tensor - it has at least one return c|jry|j}t|dkDxrtd|D}d}d}t |t j rw|jD],}t |jt js(|dz }.|jD],}t |jt js(|dz }.nt |tjj rl|jjD]"}|jjs|dz }$|jD]"}|jjs|dz }$|r xr |dk(xr|dk(S|jsyy)NFrc3jK|]+}|jduxr|jj -ywr) alias_infois_write).0rs r z>is_functional_schema..is_functional.._s25 LPqALL $ BQ\\-B-B)B BDs13r9T) is_mutablereturnsr;anyrPrCFunctionSchema argumentsrR TensorTypetorchgenmodel flat_non_outis_tensor_like) rUretsis_non_mutating_viewnum_tensor_inputsnum_tensor_outputsargretargumentret_argrTs r is_functionalz+is_functional_schema..is_functional[sa   ~~"4y1} 5 LP5 2  fe22 3''chh(8(89%*%(~~chh(8(89&!+&& = = >",,99==//1%*%:">><<..0&!+&* #!Q&B+=+B ~~rr)raz#schema must be FunctionSchema, got ) rPrCr ratorchgen.modelrparserQrR)rUrTrpras ` ris_functional_schemarsOsu"H&%((112V$$.&#%%f- fn -B4<.QRR   rtypc F|tjtjjk(xs|tjtjtjjk(xs|tjtjtjjk(xsZ|tjtjtjtjjk(Sr)r ListTypercget OptionalTyperts ris_tensorlist_like_typerzs r{{2==,,.// U "++boobmm.?.?.ABC C U "//"++bmm.?.?.A"BC C U "//"++boobmm>O>O>Q.R"ST T rc|tjjk(xs4|tjtjjk(Sr)r rcrwrxrys ris_tensor_like_typer|s: "--##% % T @Q@Q@S0T)TTrc|jdk7ry|j}t|jdk7ry|jdjy|jdjj }t|dk7ryt t|}t|jdkry|jd}|jy|jjsy|jj }t|dk7ry|t t|k7ry|jddD]}|jyy)aNCheck if an op is an inplace aten op, i.e. it mutates and returns the first arg. TODO: torchgen/model.py's FunctionSchema.parse is the source of truth for this, but not all PyTorch builds have torchgen (due to the yaml dependency being weird). Figure this out. Example: add_(Tensor(a!) x, Tensor y) -> Tensor(a) rMFr9rNT) rE_schemar;r_rY after_setnextiterrbrZ)rJrU alias_setloc first_argrls rmutates_and_returns_first_argrs# ||v ZZF 6>>a ~~a##+q!,,66I 9~ tI C 6  q   #I#    ( ($$..I 9~ d4 ?### >> %$ rcg}i}tt|jD]}|j|}|jrE|j|vr||j||j<I|j ||j<c|t|kr|j |||j |j t||fSr)ranger;rb kwarg_onlyrF default_valueappendtuple)rUrrnew_args new_kwargsiinfos r fill_defaultsrsHJ 3v''( )" ??yyF"(.tyy(9 499%(,(:(: 499%3t9}Q( 2 23* ?J &&rr.rc #$Kt|jt|t|zkr:tdt|jdt|dt|dtt|jD]}|j|}|jr"|j |vr|||j f@|t|k\r.|js!|j |vr|||j f||||fyw)zzips schema.arguments and (args, kwargs) together. Assumes that (args, kwargs) were the inputs to some torch._ops.OpOverload: that is, (args, kwargs) must be bindable to the schema (args, kwargs). z schema has z arguments but got z args and z kwargsN)r;rbrQrrrF)rUrrrrs r zip_schemars 6  s4y3v;66#f../00CCI;jY\]cYdXeel m  3v''( )" ??yyF"F499---  D >??tyyF':F499--- DGm* sDDc \ddlm}|j}t|tj j s tdd}g}|jD]}t|tjjtjjjfr|j||ct|tjjjtt fr&|j|Dcgc] }|| c}tdt#|t%j&|j(j*|}||}|j-|j.t!|j0j3t|fScc}w)Nr)FunctionSchemaGenzfx_node's target must be a hop.c|jjdd}|Q|jdk7rtd|jt |j j |j}|S)Nvalget_attrz1node.op must be 'get_attr' when val is None, got )metarwrJrQrBgraph owning_moduletarget)nodemeta_vals r_collect_example_valz5hop_schema_from_fx_node.._collect_example_valsd99==-  ww*$$G{Stzz77EHrzUnsupported arg type )torchgen.gen_schema_utilsrrrPrC_opsHigherOrderOperator RuntimeErrorrfxNoderrimmutable_collectionsimmutable_listlistrrRr. signaturerbind from_example_namerbitems) rrhoprexample_inputsrlx bound_argsexample_outputs rhop_schema_from_fx_nodersT; ++C c5::99 :<==Nyy cEHHMM588==+=+=> ?  ! !"6s"; <  %((00??uM   ! !C"HCq#7#:C"H I!6tCykBC C*N):):3<<)H)M)M *J *$/N  ) ) 5--3356n9M8O #Is>F) ct|tstdt|t |ry|j }|j syt|jdkDryy)NrLFrT) rPr rQrRrSr~r^r;r_)rJrUs rcan_generate_trivial_fake_implrs[ b* %:48*EFF"~ ZZF    6>>Q rc$ttddS)zIf an op was defined in C++ and extended from Python using the torch.library APIs, returns if we require that there have been a m.set_python_module("mylib.ops") call from C++ that associates the C++ op with a python module. REQUIRES_SET_PYTHON_MODULET)rBr r rrrequires_set_python_moduler*s ?$@$ GGrc:t|tjjjst dt |tjjj||jf\}}|Dcgc]w}t|tjr[tjj|jtjjjr t |y}}|j!||||Scc}w)Nz)curr_mode must be TorchDispatchMode, got )rPrCutils_python_dispatchTorchDispatchModerQrR_pytree tree_flattenvaluesTensorr _dispatch_keyshas DispatchKeyPython__torch_dispatch__) curr_mode op_overloadrrargs_flattened_aoverload_typess rhandle_dispatch_moder3s i!=!=!O!O P7Y7H I   ++88$ 9PQNA A a & HH # #A & * *588+?+?+F+F G Q  ' ' ^T6 RRsA.Is6%5q||%5sr`rbrUs rhas_kwarg_only_argsrHs 6V%5%56 66rc|jD];}t|jst|js.|js;yy)NTF)rbr|rRrzr)rUrs rhas_kwarg_only_tensorsrLs?   #AFF+/Fqvv/N ||   rc:td|jDS)z Given a schema, returns True if the schema has a Tensor arg. A Tensor arg is any arg with a type annotation that might involve Tensor. c3tK|]0}t|jxst|j2ywr)r|rRrzrs rr]z!has_tensor_arg..[s3!A QVV $ G(?(G G!s68rrs rhas_tensor_argrVs$ !! rct|jD]C\}}|jtjj us1|j dk(sA|cSy)zx Given a schema, returns the id of the `device: torch.device` argument. If it does not exist, returns None. deviceN) enumeraterbrRr DeviceObjTyperwrF)rUindexrls rget_device_arg_indexrasM   0 01 s 88r''++- -#((h2FL2 rallowed_nestingc#Kfd}|D]}||Ed{|jD]}||Ed{y7,7 w)Nc3Kt|tjr|ydkDr9t|ttfr"t t|idz Ed{yyy7w)Nrr9)rPrCrrr iter_tensors)rlrs rcheckziter_tensors..checkosV c5<< (I q ZeT]%C#E#JOa4GH H H&D HsAA$A"A$)r)rrrrrlkwargs ` rrrlsLI :<! sA A$A AA A cyNz???r r rrr{sUrc|Dchc]7}t|tjs|jj9}}|}t|t s|f}t |iD]_}|jj}|jj|vrt|d|d|j|aycc}w)zO custom operators' outputs must not alias any inputs or other outputs.  (with implementation in ): The output of this custom operator (1) must not also be an input to this custom operator and (2) may not alias any inputs to this custom operator or other returns. The most common way to trigger this error is if we have y = custom_op(x) and y and x are the same Tensor. Please instead return a clone of the offending output tensor(s) (e.g. return x.clone()) or refactor the custom operator to not return y.N) rPrCruntyped_storage_cdatarrradd) rFprevresult get_moduletstorages tuple_resulttensorkeys rcheck_aliasing_constraintr{s59XDqJq%,,.check_onesi==K/"ww}}o%5dii[@Yww'($15IDU#VWWX  rF)rrPrCrrziprequalisnanallpytreetree_unflattenrrrJr~r|rRrzr`) rrreal_post_hashesprepostrwas_mutated_argswas_mutated_kwargsrrwas_any_mutateds ` rrzMutationChecker.checkso^^ #)ELL9KNt C#  !!5!57GH  I T#u||,D%,,1O C& & ?YY[__&=4::<+;+;+=> I  06/D/D 0 ,,", GGOO-/A" D+ #499-$ ,(3+6+>%C DT$0-"   s .FBFN)rrrrr'rr rrrrs %1rrrcZ|jjjS)zNSome inexpensive hash. Used as a quick and dirty indicator for tensor mutation)detachfloatmean)rs rrrs 88:    " " $$rct|ry|j}tjj |drytj j j|}|tjj |drytj jjj|}|jjytjj |dryy|jyy)zIf an operator (that stays alive until FakeTensorMode) has a Fake kernel. Don't use this if the operator decomposes before FakeTensorMode. TCompositeImplicitAutogradCompositeExplicitAutogradMetaF)rrrCr %_dispatch_has_kernel_for_dispatch_key_library custom_ops_maybe_get_opdefsimple_registry singletonfind fake_implkernel _abstract_fn)rJrFopdefentrys rhas_fake_kernelr%s&b) 88D xx55 ) NN % % 6 6t J  b>66)) )+uxx||V%O%OPP r)rr impure_randomr9cJddlm}ddlm}t |t j jr*t|dd}| |jry||vry||yt |t j jrk|t jjjt jjjfvr|rt|dkDr|d|vS||yy|rt|ddry|t vryt|dd}| |jry||vryy) a An operator is impure if it: - Mutates its inputs (has a mutable schema) - Has nondeterministic/random behavior that mutates RNG state - Is explicitly marked as effectful via torch.library._register_effectful_op Args: op: The operator to check (function, OpOverload, HigherOrderOperator, etc.) args: Optional arguments that would be passed to the callable kwargs: Optional keyword arguments that would be passed to the callable impure_random: Whether to treat random operations as impure (default: True) Returns: bool: True if the callable has side effects, False otherwise r) _get_effect)_side_effectful_functionsr~NTF_nondeterministic_seeded)torch._higher_order_ops.effectsr; torch.fx.noder<rPrCrr rBr^rrD higher_orderauto_functionalizedauto_functionalized_v2r;_RANDOM_FUNCTIONS)rJrrr9r;r<rUs r is_impurerDKs.<7"ejj++,Y-  &"3"3 * * r? &"ejj445 II " " 6 6 II " " 9 9  D A Aw";;; r? &%?G  RD )F f// && r)r9)Q dataclassesr.r0collections.abcrrrtypingrrrr r rCtorch.utils._pytreerrr rdr r torch._opsr dataclassrr"intrr5rr>rIboolrSrsrzr|rrradictArgumentrrrrrrrrrrrrrrrrr%rr)r4needs_exact_stridesneeds_contiguous_stridesneeds_fixed_stride_orderr5r2r.randrandnrandintrandperm rand_like randn_like randint_likenormalpoisson bernoulli multinomialrCrDr rrr]s 88:: $$%! *** 3 3   c  eCHo  %% %5:5$5 CH:!:!4:!D:!|USUTU#j#L'$    %*38_ >B38n  eBKK$%& :&Rzd"HDHS*7 1 172#4#42,,!2!2uS$Y7GFG  *  "38n  ?B   ell  >K4IV 27171t%5<<%ELL%  --$<  1 1 eDItCy