OgRddlmZddlZddlZddlmZddlmZddlm Z ddl m Z m Z m Z mZddlZddlmZddlmZdd lmZmZmZmZdd lmZmZmZdd lmZdd l m!Z!m"Z"dd l#m$Z$m%Z%ddl&m'Z'ddl(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGer ddlHmIZIddlJmKZKd*dZL d+dZMedGddZNedGddZO d,dZPe d-dZQdd  d.d!ZR d/d"ZS d0d#ZT d1d$ZU d2d%ZV d3 d4d&ZW d5d'ZXd6d(ZYeZd)k(reYyy)7) annotationsN) defaultdict) dataclass)Path)AnyCallableTextIO TYPE_CHECKING)dest)cpp) CppSignatureCppSignatureGroupCType NamedCType)method_with_native_function"method_with_nested_native_functionwith_native_function_and_index)et_cpp)ComputeNativeFunctionStubgen_custom_ops_registration) contextArgExecutorchCppSignature)Unboxing) ETKernelIndex ETKernelKey ETParsedYaml) ET_FIELDS parse_et_yamlparse_et_yaml_struct)get_custom_build_selector get_native_function_declarations8get_native_function_declarations_from_ns_grouped_kernels(get_native_function_schema_registrations LineLoaderparse_native_yaml) BackendIndexBackendMetadataDEFAULT_KERNEL_NAMESPACE DispatchKeyFunctionSchemaLocationNativeFunctionNativeFunctionsGroup OperatorNameVariant)context FileManagermake_file_managermapMaybeNamespaceHelper)Sequence)SelectiveBuilderct|tr|jStj|j j j}|jDcgc]}|j}}djtjg|z}|d|jd|d}|Scc}w)z A wrapper function to basically get `sig.decl(include_context=True)`. For ATen kernel, the codegen has no idea about ET contextArg, so we use this wrapper to add it. ,  ()) isinstancerdeclaten_cpp returns_typefuncreturnscpp_type argumentsjoinrname)sigr?acpp_args cpp_args_strsig_decls ^/var/www/html/suriana-translation/venv/lib/python3.12/site-packages/torchgen/gen_executorch.py_sig_decl_wrapperrLAs #-.xxz(()9)9:CCEL"%--/2Q2H299joo/08;z"static_dispatch..hs=QVV=z return ::::r:z);zH ET_ASSERT_UNREACHABLE_MSG("The number of native function(s) binding to z is z .");  //  TORCH_API inline z { z } ) lenmanual_kernel_registration has_kernel get_kernelrDrC cpp_namespacekernelr@rE namespacerL)rFfbackend_indicesbbackends static_blockbackend_metadataargss rKstatic_dispatchrgQs ?q A$@$@*>aall1o>H>L 8}#A;11!4 99=S]]_==D&'7'E'E&FbIYI`I`HaabcgbhhjkLHHI }TXY\]eYfXgh KK=166(#C()*N ?s C<C<T)frozencHeZdZUded<ded<ded<ded<ed d Zy ) ComputeFunctionlist[BackendIndex]static_dispatch_backend_indicesr6selectorbool use_aten_lib Callable[[NativeFunction], bool] is_custom_opcd}|jj|jd|jjsyt j |jvrt j|jvrd}n^t j |jvrt j|jvs&td|jd|jd|jr0tj|d|jjntj|}|jr|j!|sd}|rd |jd|jd t#|d |j%d jd|j d |j'd|j%ddDd Sd |jd|jd t#|d|j d |j'd|j%Dd St)|||j*S)NFrVTCan't handle native function z* with the following variant specification .methodfallback_bindingr8rWrXz { return rr:c34K|]}|jywrQrRrSes rKrTz+ComputeFunction.__call__..s=baff=brUrOz); } z { return at::c34K|]}|jywrQrRrys rKrTz+ComputeFunction.__call__..s'H1'HrU)ra)rmis_root_operatorr_r@rEr/functionvariantsrv Exceptionrorfrom_native_functionmanual_cpp_bindingmost_faithful_signaturerrqrLrCrDrgrl)selfr`is_method_variantrFcommas rK__call__zComputeFunction.__call__s!}}-- R }.MN   1:: -'..AJJ2N $ ""ajj0W^^1::5U/x7abcblblammno     2 2%!2F2F %%''<.s(FA(FrUrsz with no returns and no out yet.zstack[z] = &;z*stack[z] = EValue(result_);z result_ = zJinternal::event_tracer_log_evalue(context.internal_event_tracer(), *stack[z]); z  z Kernel( "z",default"z [](z, EValue** stack) { zr internal::EventTracerProfileOpScope event_tracer_op_scope(context.internal_event_tracer(), "native_call_z/"); EXECUTORCH_SCOPE_PROF("native_call_z "); z (context, z ); z } ), )"r_r@rErmr|r<listet_get_selected_kernelsto_native_stringrorrrrr>argumenttype_typer?rCrrr]r^rconvert_argumentsrDrYrAoutrrBreversedrangerdefn)runbox_kernel_entryr` kernel_key kernel_metaop_namekused_kernel_keysrFrreturn_type_genrC kernel_call binding_list code_listcode_connector arg_connectorargs_strevent_tracer_output_logging output_idsrreturn_assignment ret_prefixi output_idnewlines rKrz%ComputeCodegenUnboxedKernels.__call__sA /q16H6KA6N '9!'VX#YZ   Y '()qqrqwqwq|q|p}~,,-FFKK=9  [MH:6 $%&     E@j sP$ >P)9B$P.N)r:tuple[NativeFunction, tuple[ETKernelKey, BackendMetadata]]rstr)rrrrrrrrrKrrs6'c Vc  c (c rrc  d d}|D cgc]/}|j|jD] \}} ||| ff 1c} }} rdndg |rdnd} |j| | fdddd h ycc} }}w) NcT|djdz|ddjzS)Nr:rO) root_namer)items rKkey_funczgen_unboxing..key_func+s/Aw  3&a)D)D)FFFr Functions.hNativeFunctions.hzRegisterKernels.cppz!RegisterCodegenUnboxedKernels.cppcHt|g|dk(rdSgdS)Nr)unboxed_kernels fn_header)r)rheaderitemsrmros rKzgen_unboxing..@sAD,X|DEWX "U1X- 1  1 rrOrr)key_fn env_callable num_shards sharded_keys)rrrr) get_kernelsr write_sharded) native_functionscpu_fmrmro kernel_indexmanual_registrationrnative_functionrmetadatafilenamerrs `` @@rK gen_unboxingr!sGHG G 0OO $0$<$<_$M$S$S$UO !J :x01O1OE ,m1D EF   0    '5Os4A9c t|tsJtj||j |j }|gSdfd }dDcgc]}|D] }||| c}}Scc}}w)N)r`cDj|j|dS)N)rErr)r=r^)rrrFs rKgen_declz5compute_native_function_declaration..gen_declYs#(((QRRSTTr)FT)rr'rrnrr)r<r,rrrvalues)gr metadata_listrrrrFs @rK#compute_native_function_declarationrMs a (( ( 5 5 :C ,,Q/668M U -  %   ?+ +  sA3)custom_ops_native_functionsc x|j}tt}|D] }||jj |"d}d} |D]k} t | dd} tt t|g||fd|| } |d| jd| j| d| jdz }m|S)a Generates namespace separated C++ function API inline declaration/definitions. Native functions are grouped by namespaces and the generated code is wrapped inside namespace blocks. E.g., for `custom_1::foo.out` in yaml file we will generate a C++ API as a symbol in `torch::executor::custom_1::foo_out`. This way we avoid symbol conflict when the other `custom_2::foo.out` is available. rNr) namespace_str entity_name max_levelcduxr|vSrQr)r`rs rKrz,gen_functions_declarations..s+Fd+R,988r)rlrmrorqr) _to_backend_indexrrr_appendr4r3rjprologuerDepilogue) rrrmror backend_indexns_grouped_functionsrfunctions_declarationsrr_ ns_helper declarationss ` rKgen_functions_declarationsrcs*!224M&t,+P_667>>OPG) ##  5BO%!-"9 %Y/    ' l  #  % . "!rcDtt}|D]}t}|j|}|j D][}|r|j }|j |nt}t|dks Jd|||j|||]|S)NrOz6Codegen only supports one namespace per operator, got ) rrsetrrr]addr(rYextend) rrnative_function_decl_genns_grouped_kernelsr`native_function_namespaces op_kernelsrer_s rKget_ns_grouped_kernelsrs0;4/@ %(U"!--a0 * 1 1 3  ,:: *..y94 ./14 eGHbGcd e4 y ) 0 0(L9   rc  dgtjji|r(|jddfdj d|j dfd|j dd d d d gi r, d j d |j d fdyt t |j d fdy)a%Generate headers. Args: native_functions (Sequence[NativeFunction]): a collection of NativeFunction for ATen ops. gen_custom_ops_header (bool): whether we should generate CustomOpsNativeFunctions.h custom_ops_native_functions (Sequence[NativeFunction]): a collection of NativeFunction for custom ops. kernel_index (ETKernelIndex): kernel collection cpu_fm (FileManager): file manager manages output stream use_aten_lib (bool): whether we are generating for PyTorch types or Executorch types. z#include zCustomOpsNativeFunctions.hrcFttjddgdS)Ngrouped_native_functionsrarz#include z#include )nativeFunctions_declarationsheaders)r!r r)rarsrKrzgen_headers..s.0P-H$3-1-U-U1 -. r%#include "CustomOpsNativeFunctions.h"rc4rndgtdS)Nz#include "NativeFunctions.h")rrrmror)static_dispatch_extra_headersFunctions_declarations)r) aten_headersrrrrmrosrKrzgen_headers..s/.:01&@!1)!),G '  rzRegisterKernels.hc ddiS)Ngenerated_commentz(@generated by torchgen/gen_executorch.pyrrrrKrzgen_headers..s !P rrzK#include // at::Tensor etc.z=#include z3#include // TORCH_APIcTtdttjifiS)Nrr)dictr!r r)rarrsrKrzgen_headers..s5D24T1A(7151Y1Y5  r)rrrc4tdtifiS)Nr)r)rr")rrsrKrzgen_headers..s)D24l+=5  rN)r)CPUrwrite_with_templaterwriterr) rgen_custom_ops_headerrrmrrrorrarrs ` ``` `@@@@rK gen_headersr s(22L" (F(F(HIO"" (    CD LL  LL   Y K G  !!"WX   4-%%H     rc tjt|||\ |jddd fd|jddd fdt |\|j d fd y) N)rrmrrocmRegisterz CustomOps.cppz RegisterDispatchKeyCustomOps.cppc2djddS)NrrN ops_headersr)dispatch_namespacedispatch_namespaced_definitionsdispatch_anonymous_definitions"static_init_dispatch_registrations)lower)anonymous_definition dispatch_keyrsrKrz gen_custom_ops..1s%B'"."4"4"6/1.B2T  rzStub.cppc hdjdtttdS)NrNr)rrr3r)rrrsrKrz gen_custom_ops..=s<'"."4"4"6/1.2246FG/3U  r)rschema_selectorzRegisterSchema.cppcdS)N)schema_registrationsaten_schema_registrationsr)rrsrKrz gen_custom_ops..Rs$8)B r)r)rrrr#r) rrmrrr rrrrrs ` @@@@@rKgen_custom_opsrs??L $)!   *  <. .*    <.)*  $ 1)  !  LL rc|r4t|5}|j|jdddyt||dd\}}|Dcic]2}|j|j d|jj 4} }| jD cic]\} } | j | } } } | jD cic]\} } | t| } } } |jDcic] \}}| || }}}|rAtjj|r"tj|jdk(ryt|5}tj|t }|s dddy|D]}t#|j%dt&sJ|t)||j+dt-fd5d |vrd |d <d |vr dddjt#|j%d tsJ||j+d }d|vrd |z}|| vsJ| j%||d <||vr ||jD] \}}|||< dddtj.||ddddy#1swYyxYwcc}wcc} } wcc} } wcc}}w#1swY@xYw#1swYyxYw)aTranslates Executorch DSL dialect to use the same syntax as native_functions.yaml. The major difference is that Executorch DSL dialect supports "op" key, where it refers to the operator name in native_functions.yaml. For example, a functions.yaml may have the following entry: - op: add.out ... It needs to be translated to the following: - func: add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!) ... We go in aten_yaml_path and find the operator schema for "add.out" and add it to the original functions.yaml. We also add required field "variants", where for Executorch it will always be "function". For ATen mode we don't have to do the translation because native_yaml_path is the same as native_functions.yaml. Args: tags_yaml_path: Path to a tags.yaml file to satisfy codegen parsing. It is not optional. aten_yaml_path: Path to ATen operator yaml file native_functions.yaml. native_yaml_path: Path to a functions.yaml file to parse. If the path does not exist in the filesystem, it is treated as an empty file. If `custom_ops_yaml_path` exists, the contents of that file are appended to the yaml input to be parsed. use_aten_lib: We use this flag to determine if we want to generate native functions. In ATen mode we should generate out= variants. out_file: The IO object that we are writing into. Returns: None NF)skip_native_fns_genrVrLoader__line__cddS)Nzin z: r)locsrKrz'translate_native_yaml..s3se5!1rr~r}r@opzaten::i)width)open writelines readlinesrr@r_rErrospathexistsstatst_sizeyamlloadr$r<getintr+popr0dump)tags_yaml_pathaten_yaml_pathnative_yaml_pathroout_file aten_yamlrpersisted_fieldsr`func_to_scoped_namer@rEop_to_scoped_name schema_dictr%vkernel_persist_dict native_yaml native_esrzopnamerr$s @rKtranslate_native_yamlrCYsT . ! 7Y    3 3 5 6 7)6 ! *&&:J6451;;-r!&&++//66+>*C*C*E2&D$ 4226I5N5N5PQztT4T?QKQ.>.D.D.F6%*R"q 66 ww~~./ 77# $ , , 1  3;IIk*=  33 !AaeeJ/5 8q 85+QUU:->?C12 !Q&$.AjMQ;  ! ! "!%%+s36Q63tv%%.F,,,'OOF3& 00 3F ; A A C!1 !! ! ! !( )XT2133; 762R6" ! !33s[ J7JJ#J)3J/K=AKJ5 K)A>J5'"KJ5J? :KK cv|rtjj|rttj|jdkDrQt |5}t j|t}dddtdDr t|nd}|D]}tD]}|j|d!t||d||} tt|| j } | Dcgc]}|j"j$c}|?|j&j)D cic] \} } | vr| | } } } | t+| fS dfd }| j,j)Dcic]\}}|||j&}}}| |fSgifS#1swY0xYwcc}wcc} } wcc}}w)Nrr c3$K|]}d|v yw)kernelsNrrys rKrTzparse_yaml..s+GqIN+Gs)r loaded_yaml)indexc@|Dcic] }|vs|||c}Scc}wrQr)mr%op_namess rK map_indexzparse_yaml..map_indexs')*<"R8^B"I< <)>)B $Z 111Z0B 1 ),+GB+G(G  $T   'E" ' %& ' '(    3    8T8T UV)9:AAFFKK:  #0.function_filters33A66rztranslated.yamlwT)r`r,rrn) tempfileTemporaryDirectoryr*r+rDr'rCrWr<rfrom_backend_indices merge_indicesr)r5r6r7custom_ops_yaml_pathrmror\rP tmpdirnametranslated_yaml_path translatedtranslated_functionstranslated_indicescustom_ops_functionscustom_ops_indicescombined_functionscombined_kernel_index combined_yamlcustom_ops_parsed_yamls ` rKparse_yaml_filesrlsT<7  $ $ &X*!ww||J8IJ & ,  !    4> ./|CS4 004> ./44 00 ,m 0 00;  X> 0 00s$-D D B(D D DD%c 6tjd}|jddd|jddd |jd d d |jd dd|jddddd|jddd|jddd|jdddd !|jd"d#dd$!|jd%d&d'|jd(d)|jd*dd+|jd,d-dd.|jd/d0dd1|jd2tdd3d4gd3d4gd56|j }|j sJd7t |j|j}t|j|j |j|j||j8\}}|j|j}}|r |jng}t!|9}d3|j"vr&t%||j|||||j:d4|j"vrAt'||||j||j(;|rt+|||||j,<|j.r{t1|j.j3} | j4} | j6} |d=ffD]7\} } | | z}| j8| | zz }| j;|t|9yy)>NzGenerate operator source files) descriptionz-sz --source-pathz-path to source directory for kernel templates)helpz--functions-yaml-pathz--functions_yaml_pathzpath to the functions.yaml file to use. Optional, but at least one of --functions-yaml-path and --custom-ops-yaml-path must be specified.z--custom-ops-yaml-pathz--custom_ops_yaml_pathzpath to the custom_ops.yaml file to use. Optional, but at least one of --functions-yaml-path and --custom-ops-yaml-path must be specified.z--aten-yaml-pathz--aten_yaml_pathz#path to native_functions.yaml file.z-dz --install-dirz --install_dirzoutput directoryzbuild/generated)rorz-oz--output-dependenciesz:output a list of dependencies into the given file and exitz --dry-run store_truez5run without writing any files (still updates outputs))actionroz--static-dispatch-backendz--static_dispatch_backend*z?generate static dispatch code for the specific backend (if set))nargsroz--op-registration-whitelistz--op_registration_whitelistzfilter op registrations by the whitelist (if set); each item is `namespace`::`operator name` without overload name; e.g.: aten::empty aten::conv2d ...z--op-selection-yaml-pathz--op_selection_yaml_pathaDProvide a path to the operator selection (for custom build) YAML that contains the information about the set of selected operators and their categories (training, ...). Each operator is either a full operator name with overload or just a bare operator name. The operator names also contain the namespace prefix (e.g. aten::)z --tags-pathz>Path to tags.yaml. Required by yaml parsing in codegen system.z--rocmz=reinterpret CUDA as ROCm/HIP and adjust filepaths accordinglyz--use-aten-libz--use_aten_libzka boolean flag to indicate whether we use ATen kernels or not, in the future this flag will be per operatorz--manual_registrationz--manual-registrationzfa boolean flag to indicate whether we want to manually callregister_kernels() or rely on static init. z --generatersourceszGenerate only a subset of files)typerschoicesrroz.tags.yaml is required by codegen yaml parsing.)r6r5r7r`rmro)options)rr rrmrrro)rrrmrorr)rrmrrr rN)argparseArgumentParser add_argumentr parse_args tags_pathr op_registration_whitelistop_selection_yaml_pathrlr6functions_yaml_pathr`rorrr2generater rrrr output_dependenciesrresolverEstemparent write_outputs)parserrwrmrTrkrrrr depfile_path depfile_name depfile_stemfmprefixvarnamer+s rKmainr;s  $ $1Q RF   <       2    !    I  D  ## N   %%-  ""M  M  L    6   I&I& . !G   NNN ())&&H +;--(( 44$99)) +'K' $$  # 4J//r w /FG$$$-")">">(C% -- G$$$- --% ' ; ;   ' !<!)\\  ""G778@@B #(( #(( RL  1JB|+G&&&<*?@D   Wc$i 0  1 #r__main__)rF%CppSignature | ExecutorchCppSignaturerr)rFrr`r,rarkrr)rSequence[NativeFunction]rr1rmr6rornrrrrnrNone)rz%NativeFunctionsGroup | NativeFunctionrrrz list[str]) rrrrrmr6rornrzSequence[NativeFunction] | Nonerr)rrrrrzKCallable[[NativeFunctionsGroup | NativeFunction, ETKernelIndex], list[str]]rzdict[str, list[str]])rrr rnrrrmr6rrrr1rornrr) rrrmr6rrrr1r rnrr) r5rr6rr7rrornr8r rr)F) r+rr5rrPrprrnrzctuple[list[NativeFunction], dict[DispatchKey, dict[OperatorName, BackendMetadata]] | ETKernelIndex])r5rr6rr7rr`rrmr6rornrz(tuple[ETParsedYaml, ETParsedYaml | None])rr)[ __future__rrxr* collectionsr dataclassesrpathlibrtypingrrr r r/torchgenr torchgen.apir r>torchgen.api.typesr rrrtorchgen.contextrrrtorchgen.executorch.apir"torchgen.executorch.api.custom_opsrrtorchgen.executorch.api.typesrr torchgen.executorch.api.unboxingrtorchgen.executorch.modelrrrtorchgen.executorch.parserrr torchgen.genr r!r"r#r$r%torchgen.modelr&r'r(r)r*r+r,r-r.r/torchgen.utilsr0r1r2r3r4collections.abcr5!torchgen.selective_build.selectorr6rLrgrjrrrrrr rrCrWrlrrrrrKrsd" #!77 (QQ +M5NNTT   (B  # .##(# #P $666t $i i i X).) ) )  )  )) )X ,a .a  a ": a  a  a  a a  a H:.:: :  :  : :z`3`3`3!`3 `3  `3  `3N!& 6 6666 6  6rC1C1C1!C1% C1  C1  C1.C1Li1X zFr