L iBDUddlmZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZmZmZmZmZmZmZmZm Z m!Z!da"de#d<ddZ$dd Z%ed d Z& dd Z'dddZ(ddZ)ddZ*ddZ+GddZ,Gdd Z-GddZ.y)) annotations)Any) BaseCppType BaseCTypeboolTCTypedeviceTdoubleT generatorTlayoutT ListCTypelongT memoryFormatT NamedCType OptionalCTypescalarT scalarTypeTstringTSymIntT VectorCType) ArgumentBaseTyBaseTypeFunctionSchemaListType OperatorName OptionalTypeReturnTensorOptionsArgumentsTypeNzBaseCppType | None_valueTc0ts tdtS)NzHThe value type needs to be set with setValueT() in run_gen_lazy_tensor())r!NotImplementedErrorW/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/torchgen/api/lazy.py getValueTr'2s ! V   Nr%c|ayN)r!)vals r& setValueTr+<sGr%z torch::lazyValueLazyIrPropertiesct|tr_|jtjk(rt t S|jtjk(r.|jrt tSt t S|jtjk(rt tS|jtjk(rt tS|jtjk(r$|rt t St tS|jtjk(rt t S|jtj"k(rt t$S|jtj&k(rt t(S|jtj*k(rt t,S|jtj.k(rt t0S|jtj2k(rt t4S|jtj6k(rt t8St;dt=|t|t>r!tAtC|jD||St|tFrt'|jDdk(r%tItAt t St'|jDdk(rt tJS|jDttjk(rtMt tStMtC|jD||St;dt=|)a This function takes a type from NativeFunctions and converts it for use with lazy tensor codegen. Type conversion for lazy currently consists of (1) changing at::Tensors into lazy::Values (2) wrapping everything in a BaseCType (3) making cpp-reference types into cpp-value types (e.g. vector instead of IntArrayRef) (1) converts at::Tensors to lazy::Values (which wrap lazy::Nodes, with which Lazy IR represents tensors.) There is special handling for Optional[Tensor] or list[Tensor], etc- hence 'tensor-like' This is incomplete- there are assertions in places that it's expected to need to add more types as the codegen is used with more operators. zTODO add support for type symintzTensor?Tensorzunrecognized type )' isinstancernamerr1rr'ScalarTreatScalarsAsConstantsr ScalarTyperintrSymIntboolrfloatr strrDevicer Generatorr Layoutr MemoryFormatrAssertionErrorreprrrprocess_ir_typeelemrr tensorListValueTr)typ propertiesr0s r&rBrBFs`$#x 88v}} $Y[) ) XX &11 ))Y[) ) XX** *[) ) XX #U# # XX & -- '' XX $U# # XX %W% % XX #W% % XX &W% % XX)) )Z( ( XX &W% % XX,, ,]+ + #=d3i[!IJ J C &_SXXz&QRR C " sxx=I %]9Y[+ABC C ]h &-. . XX&--0 0y/0 0sxxFST T1$s)=>>r%cjt|trV|xr |j}|jt k(xs-|jt k(xr| xs|jt k(S|ttt k(ryt|tttfrt|j|Sy)z Given a type, determine if it is a Value-like type. This is equivalent to being Tensor-like, but assumes the type has already been transformed. F) r2rr5typer'rrrrr isValueTyperC)rErFtreat_scalars_as_constantss r&rIrIs #y!&0%VJ4V4V" HH # #G#F,F(F #xx7" Ig./ / C-K@ A388Z00 r%c`t|txr|jtjk(Sr))r2rr3rr8rEs r& isSymIntTyperMs! c8 $ BV]])BBr%ct|tr|jtjk(St|t t frt|jSy)a Given a type, determine if it is a c10::scalar which we will wrap in a lazy Value. Since we literally change the type from scalarT to valueT, information is lost. This function helps build a list of wrapped scalars to save that information F) r2rr3rr4rrisWrappedScalarTyperCrLs r&rOrOsD #x xx6==(( C,1 2"388,, r%ct|tr|jtjk(St|t rt |jSy)NF)r2rr3rr=risGeneratorTyperCrLs r&rQrQs=#x xx6++++ C, (sxx(( r%ceZdZUded<ded<ded<ded<ded <ded <ded <ded < dd ZeddZy) LazyArgumentr;r3r orig_typez CType | None lazy_type_r9is_wrapped_scalar is_generatoris_symint_or_listr0 is_lazy_valuec"|j|_|j|_||_t |jt |_t|j|_t|j|||_ t|j|_ |xrRt|jxs;t |jt xrt|jj|_t!|j"||_y)Nr/)r3rHrTr0r2r is_optionalrQrWrBrUrOrVrMrCrXrI lazy_typerY)selfargrFr0s r&__init__zLazyArgument.__init__sHH  %chh =+CHH5)#((JvN!4SXX!>!'"  " T388\2R|CHHMM7R )Dr%cZ|jJd|j|jS)Nz3Attempted to access lazy_type for invalid argument )rUr3r]s r&r\zLazyArgument.lazy_types3* A$)) M *r%N)r^rrFr-r0r9returnNone)rbr)__name__ __module__ __qualname____annotations__r_propertyr\r$r%r&rSrSsq IO LEE)9EFJE E&r%rSc8eZdZUdZdZded<d dZd dZd dZy) r-aDCollection of properties for an IR node The property groups are listed below. Each group is mutually exclusive, meaning that only one property from each group can be True at any one time. The properties can be accessed as if they were normal attributes. The mutual exclusivity is automatically handled. ))ShapePrecompute ShapeCompute ShapeCache)Lower LowerDeclOnly) CanBeReusedCanBeReusedDeclOnly)CreateFnCreateFnDeclOnly)r5ztuple[tuple[str, ...], ...] Propertiesctjtj}||jd<|D]}t ||dy)NrFT)dictfromkeysr-rs__dict__setattr)r]default_propertiesrFps r&r_zLazyIrProperties.__init__sD8<  ' '9 '1 l## #A D!T " #r%c|jd}tjD]}||vs|||k(cS|j|S)NrF)rwr-rs__getattribute__)r]keyrFvaluess r& __getattr__zLazyIrProperties.__getattr__sO]]<0 &11 1Ff}!&)S00 1$$S))r%c|jd}tjD]}||vs|r|nd||<|cStd|)NrFzInvalid property: )rwr-rsKeyError)r]r}valuerFr~s r& __setattr__zLazyIrProperties.__setattr__&sT]]<0 &11 Ff},1St 6"   +C5122r%N)ryr;rbrc)r}r;rbr)r}r;rrrbr) rdrerf__doc__rsrgr_rrr$r%r&r-r-s%/J+.#*3r%cFeZdZUded<ded<ded<ded<dZd ed <d ed <d ed<edddZded<dZded< d d dZe d!dZ e d!dZ e d!dZ d" d#dZ e d$dZe d$dZe d$dZe d$dZy)% LazyIrSchemarr3ztuple[LazyArgument, ...]positional_args keyword_argsztuple[Return, ...]returnsNzNamedCType | None generator_argrfuncr9r0rjrmror-rFz str | Noneopkindc|r|_|__g}dD]}|dk(r^|jjH|jjj }|j t|jft|j|}|jfdt|j|Dt|_ g}dD]}t|j|}|t|tr|j}|D]P}t|j sj"Jdt%|j&|j _R|jfd|Dt|_|j&_|j*_y)N)pre_self_positionalself_argpost_self_positionalrr/c3NK|]}t|jywr/NrSrF.0r^r]r0s r& z(LazyIrSchema.__init__..fs)'!doofEE'"%)pre_tensor_options_kwarg_onlytensor_optionspost_tensor_options_kwarg_onlyoutz)We expect there is only one generator argc3NK|]}t|jywrrrs r&rz(LazyIrSchema.__init__..s)$!doofEE$r)rFrr0 argumentsrargumentappendrSgetattrextendtuplerr2rallrQrHrrr3rr) r]rrFr0r arg_fieldr^r curr_argss ` ` r&r_zLazyIrSchema.__init__Rs (DO  .0T IJ&4>>+B+B+Nnn--66&& doofE3?&&'&t~~yA'  %_5+-   I   :I$i)?@ ) I$C&sxx0#119G9.8HHHH.* ##$($' .",/II || r%c|jjd|jjj}djd|j dDS)z Return camel-case version of op in node. Note: This function also appends any `overload_name` in the operation. For example, if the op is `bitwise_and.Tensor`, the returned name will be `BitwiseAndTensor`. _c3DK|]}|jxsdyw)rN) capitalize)rwords r&rz)LazyIrSchema.node_name..sN4t(.B.Ns )r3 overload_namelowerjoinsplit)r]op_names r& node_namezLazyIrSchema.node_namesOYY^^$Adii&=&=%>?EEGwwN7==;MNNNr%c@t|jjSr))r;r3ras r& aten_namezLazyIrSchema.aten_names499>>""r%cD|jjjSr))r3baseras r& base_namezLazyIrSchema.base_names))..%%&'r%cg}|r|j|j|r|j|j|r|r|r|S|r|r|Dcgc]}|jr|c}S|r|Dcgc]}|js|c}S|r*|Dcgc]}|js|s |js| c}SgScc}wcc}wcc}wr))rrrrWrY)r] positionalkeywordr~scalars generatorargsas r& filtered_argszLazyIrSchema.filtered_argss$&  KK,, -  KK)) * g)K #:!1>>A: : #7!qA7 7 IQ^^   ;7s B3B3,B8>B8 #B=c,|jddddSNTFrrr~rrras r&positional_valueszLazyIrSchema.positional_valuess#!!U4"  r%c,|jddddSrrras r&positional_scalarszLazyIrSchema.positional_scalarss#!!U5$"  r%c,|jddddSNFTrrras r&keyword_valueszLazyIrSchema.keyword_valuess#!!d4"  r%c,|jddddSrrras r&keyword_scalarszLazyIrSchema.keyword_scalarss#!!d5$"  r%r))rrrFLazyIrProperties | Noner0r9rbrc)rbr;)TTTTT) rr9rr9r~r9rr9rr9rblist[LazyArgument])rbr)rdrerfrgrr-rFrr_rhrrrrrrrrr$r%r&rr6so --** (,M$+  L#3 $J  FJ /34$4$,4$  4$  4$l O O##((            D        r%r)rbr)r*rrbrc)rEr rFr-r0r9rbz3BaseCType | VectorCType | OptionalCType | ListCTyper))rErrFrrbr9)rEr rbr9)/ __future__rtypingrtorchgen.api.typesrrrrr r r r r rrrrrrrrrtorchgen.modelrrrrrrrrrr r!rgr'r+rDrBrIrMrOrQrSr-rr$r%r&rs"(   # "}g6J? J?+J?8<J?8J?d,C  ''T7373@^ ^ r%