a dk @s,ddlZddlZddlZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZddlZddlmZddlmZddlmZmZmZmZddlmZmZdd lmZdd l m!Z!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;mZ>m?Z?eee$fe4e e/e@dddZAeddGdddZBeddGdddZCe e4eEz#static_dispatch..N, css|] }|jVqdSNname)r4ar3r3r7 Jr9z"static_dispatch..z return ::::(z);zH ET_ASSERT_UNREACHABLE_MSG("The number of native function(s) binding to z is z .");  //  TORCH_API inline z { z } ) lenZmanual_kernel_registration get_kerneljoin argumentsZ cpp_namespacekernelfuncr> namespacedecl)r.r/r0backendsZ static_blockZbackend_metadataargsr3r6r7static_dispatch3s. rOT)frozenc@sTeZdZUeeed<eed<eed<ee gefed<e e e e dddZ dS) ComputeFunctionstatic_dispatch_backend_indicesselector use_aten_lib is_custom_opr/r1cCs|j|jd|jjs dStj|jvr0dS|jrLt j |d|j d nt |}|jr||sd}d|jd|jd|d|d|d d |Dd St|||jd SdS) NrAFmethodZfallback_bindingr;rCrDz { return at::rBcss|] }|jVqdSr<r=r4er3r3r7r@xr9z+ComputeFunction.__call__..z); } )r0)rSis_root_operatorrKrJr>r'functionvariantsrTrfrom_native_functionmanual_cpp_bindingmost_faithful_signaturerrUrLrGrHrOrR)selfr/r.commar3r3r7__call__es8  zComputeFunction.__call__N)__name__ __module__ __qualname__rr__annotations__r(boolrr$rrstrrcr3r3r3r7rQ[s  rQc@s2eZdZUeed<eed<eeedddZ dS)ComputeCodegenUnboxedKernelsrSrTrVc Cs|j|jd|jjs dS|jrJtj|d|jd }t j }t j }nt |}tj }tj }t|d|\}}d}d}|dd |D} t|jjd krt|jjjd krtd |jd |jjjd } d t|d| jd} d} nBt|jjjd kr0dt|d} ||jjd} nd} d} d|jd|jjd||d|jjd| d|jd|d| d| dS)NrAr2FrW)argument_type_genz r;css|] }|jVqdSr<r=rYr3r3r7r@r9z8ComputeCodegenUnboxedKernels.__call__..rzCan't handle native function z with no returns and no out yet.zstack[z] = &;z*stack[z] = EValue(result_);z result_ = z Operator( "z$", [](EValue** stack) { z- EXECUTORCH_SCOPE_PROF("native_call_z "); ztorch::executor::rBz ); z } ), )rSr[rKrJr>rTrr^r_r`aten_cppZargumenttype_typeZ returns_typerrrZconvert_argumentsrHrGrEreturnsout ExceptionZcpp_type) rar/r.rkZreturn_type_genZ binding_listZ code_listZcode_connectorZ arg_connectorargs_strroZreturn_assignmentZ ret_prefixr3r3r7rcsh    z%ComputeCodegenUnboxedKernels.__call__N) rdrerfr(rgrhrr$rircr3r3r3r7rjs rj)native_functionscpu_fmrSrTr1cs>tttftddd}|jd||fddddhd dS) N)fnr1cSs|jSr<) root_namertr3r3r7key_funcszgen_unboxing..key_funcz!RegisterCodegenUnboxedKernels.cppcsdt|giS)N unboxed_ops)rjrvrSrTr3r7szgen_unboxing..r:rx)Zkey_fnZ env_callableZ num_shardsZ sharded_keys)r r$r%riZ write_sharded)rrrsrSrTrwr3ryr7 gen_unboxings r{)g backend_indexr1cCsZt|tsJtj|d}||}|dur0gS|jr:dnd}|d|j|jddgS)Nr6ZstaticZ TORCH_API r=rl) isinstancer$rr^rFexternalrLrI)r|r}r.metadataprefixr3r3r7#compute_native_function_declarations  rcustom_ops_native_functions)rrstatic_dispatch_idxrSrTrr1c stt}|D]}||j|q d}d}|D]^} t| ddd} ttt|||fddd|| } |d| jd|| d| j d7}q.|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. r2 )Z namespace_str entity_nameZ max_levelcsduo|vSr<r3r6rr3r7rz sz,gen_functions_declarations..)rRrSrTrUz ) rlistrKappendr-r,rQZprologuerGepilogue) rrrrSrTrZns_grouped_functionsZnative_functionZfunctions_declarationsnewlinerKZ ns_helperZ declarationsr3rr7gen_functions_declarationss<   r)rrrrrSr0rsrTr1c sfdgr,|ddfddd|dfdd|dfd ddS) Nz#include zCustomOpsNativeFunctions.hzNativeFunctions.hcsdttjdiSNZnativeFunctions_declarations)Zgrouped_native_functionsr0Znative_function_decl_genrr rr3)r0rr3r7rz*s zgen_headers..%#include "CustomOpsNativeFunctions.h"z Functions.hcs"rndgtddS)Nz#include "NativeFunctions.h")rrrrSrTr)Zstatic_dispatch_extra_headersZFunctions_declarations)rr3) aten_headersrrrrSrrTr3r7rz5scsdtrtjntdiSrrr3)r0rrrTr3r7rzEs)write_with_templaterwriterrrrrSr0rsrTr3)rr0rrrrSrrTr7 gen_headerss   r)rrrSr0rsrocmr1cstj|}t|||d\|dddfdd|dddfddt|d \|d fd ddS) N)rrrSr}rZRegisterz CustomOps.cppz RegisterDispatchKeyCustomOps.cppcsdddS)Nrr2Z ops_headersr!Zdispatch_namespaceZdispatch_namespaced_definitionsZdispatch_anonymous_definitions"static_init_dispatch_registrations)lowerr3)anonymous_definition dispatch_keyrr3r7rzgsz gen_custom_ops..zStub.cppcs"ddtttdS)Nr2r)rrr,rr3)rrrrr3r7rzss )rrZschema_selectorzRegisterSchema.cppcs dS)N)schema_registrationsaten_schema_registrationsr3r3)rrr3r7rzs)r!CPUrrrr)rrrSr0rsrr}r3)rrrrrrrr7gen_custom_opsQs@    r)tags_yaml_pathaten_yaml_pathnative_yaml_pathrTout_filer1c s|r@t|d}||Wdn1s20YdSt||ddd}|j}dd|D}|rtj|rt|j dkrdSt|d"} t j | t d} | sWddS| D]} t | d tsJ| t|| d tfd d d | vr d | d <d| vr$Wdqt | dts>J| | d} d| vrZd| } | |vshJ|| | d<Wdq1s0Yqt j| |ddWdn1s0YdS)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 rNFskip_native_fns_gencSs(i|] }|jd|jjt|jqS)rA)rKrJr>rir4r/r3r3r7 sz)translate_native_yaml..r)LoaderZ__line__cs ddS)Nzin z: r3r3locr3r7rzr9z'translate_native_yaml..r]r\rJoprAzaten::i)width)open writelines readlinesrrrospathexistsstatst_sizeyamlloadrrgetintr#popr)ridump) rrrrTrZ aten_yamlZaten_parsed_yamlZaten_native_functionsZ schema_dictZ native_yamlZ native_esrZopnamer3rr7translate_native_yamlsP* ,     0r)bsr1cCs<tdd}|D]"\}}t|ddt||d||<q|S)NcSsttjdddidS)NTFrZuse_out_as_primaryrZ device_guardindex)rr! Undefinedr3r3r3r7rzs z)convert_backend_indices..TFr)ritemsrr")rindiceskvr3r3r7convert_backend_indicess  rF)rrfunction_filterrr1cs|rtj|rt|jdkrt||d|d}tt||j}dd|Dt t t ft t t fdfdd fdd |j D}||fSgifSdS) NrrcSsg|] }|jjqSr3)rJr>rr3r3r7r8 r9zparse_yaml..)mr1csfddDS)Ncsi|]}|vr||qSr3r3)r4r)rop_namesr3r7rr9z1parse_yaml..map_index..r3r)rrr7 map_index szparse_yaml..map_indexcsi|]\}}||jqSr3)r)r4rr5)rr3r7rszparse_yaml..)rrrrrrrfilterrrrr&r r0r)rrrr parsed_yamlrrr0r3)rrr7 parse_yamls"    r)rrrcustom_ops_yaml_pathrSrTr1c s0ddl}ttdfdd }|}tj|d} t| d } t||||| Wdn1sd0Yt | ||| \} } t |||d\} }| | }t t }| | |D]8}||vr| |||iqi||||||<qt |t|}t | t|}Wdn1s0Y||fS) aParses functions.yaml and custom_ops.yaml files. 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. custom_ops_yaml_path: Path to a custom_ops.yaml file to parse. If the path does not exist in the filesystem, it is ignored. selector: For selective build. use_aten_lib: We use this flag to determine if we want to generate native functions. In ATen mode we should generate out= variants. Returns: A tuple with two elements: [0]: The parsed results of concatenating the contents of `native_yaml_path` and `custom_ops_yaml_path`. [1]: The parsed results of the contents of `custom_ops_yaml_path`, if present. If not present, None. rNrVcs |Sr<)Zis_native_function_selectedr6rSr3r7r:sz)parse_yaml_files..function_filterztranslated.yamlwT)tempfiler$rhTemporaryDirectoryrrrGrrrrdictupdaterr)rrrrrSrTrrZ tmpdirnameZtranslated_yaml_pathZ translatedZtranslated_functionsZtranslated_backend_indicesZcustom_ops_functionsZcustom_ops_backend_indicesZcombined_functionsZcombined_backend_indicesZdkZ combined_yamlcustom_ops_parsed_yamlr3rr7parse_yaml_filessJ  "   $r)r1c Cs>tjdd}|jdddd|jddd d|jd d d d|jd ddd|jdddddd|jdddd|jdddd|jdddd d!|jd"d#dd$d!|jd%d&d'd|jd(d)d|jd*dd+d|jd,d-dd.d|jd/tdd0d1gd0d1gd2d3|}|jsJd4t|j|j}t |j |j|j |j ||j d5\}}|j|j}}|rd|jng}t|d6}|tjg} d0|jvrt||| ||||j d7d1|jvrt||||j d8|rt|||||jd9|jr:t|j} | j} | j} |d:ffD]0\} }|| }| j|| }| |t|qdS);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)rdefaultz-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))actionrz--static-dispatch-backendz--static_dispatch_backend*z?generate static dispatch code for the specific backend (if set))nargsrz--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 --generateheaderssourceszGenerate only a subset of files)typerchoicesrrz.tags.yaml is required by codegen yaml parsing.)rrrrrSrT)optionsr)rrrsrSrT)rrrSr0rsrr2) argparseArgumentParser add_argumentri parse_argsZ tags_pathrZop_registration_whitelistZop_selection_yaml_pathrrZfunctions_yaml_pathrrTrrr0r+r!rgeneraterr{rrZoutput_dependenciespathlibPathresolver>stemparentZ write_outputs)parserrrSrrrrr0rrsrZ depfile_pathZ depfile_nameZ depfile_stemZfmrvarnamerr3r3r7mainfs         r__main__)F)Prrr collectionsrZ dataclassesrtypingrrrrrr r r rZtorchgenr Z torchgen.apir rmZtorchgen.api.typesrrrrZtorchgen.contextrrZtorchgen.executorch.apirZ"torchgen.executorch.api.custom_opsrrZtorchgen.executorch.api.typesrZ torchgen.executorch.api.unboxingrZ torchgen.genrrrrrrZtorchgen.modelrr r!r"r#r$r%r&r'Z!torchgen.selective_build.selectorr(Ztorchgen.utilsr)r*r+r,r-rirOrQrjrhr{rrrrrrrrrrdr3r3r3r7s  (      ,   ()D    2  8  ? T    M%