U 9%e҅ @sddlZddlZddlZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZddlZddlmZddlmZddlmZmZmZmZddlmZmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJmKZKeee'feLdddZMeee'fe@e e:eLdddZNeddGdddZOeddGdddZPe e@eHeEeQe+ddd d!ZReeeAe@fe+e eLd"d#d$ZSdd%e e@e+eEeQe e e@eLd&d'd(ZTe e@e+e eeAe@fe+ge eLfe eLe eLfd)d*d+ZUe e@eQe e@eEe+eHeQdd,d-d.ZVe e@eEe+eHeQdd/d0d1ZWeLeLe eLeQedd2d3d4ZXd@e eLeLe e@geQfeQee e@ee e=e eBe;ffe+ffd6d7d8ZYeLeLe eLe eLeEeQee-e e-fd9d:d;ZZdd<d=d>Z[e\d?kr~e[dS)AN) defaultdict) dataclass) AnyCallableDictListOptionalSequenceTextIOTupleUnion)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)SelectiveBuilder)context FileManagermake_file_managermapMaybeNamespaceHelper)sigreturncCsht|tr|St|jj}dd|D}d t g|}|d| d|d}|S)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. cSsg|] }|qS)decl.0ar:r:V/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/torchgen/gen_executorch.py Dsz%_sig_decl_wrapper..,  ()) isinstancerr;aten_cpp returns_typefuncreturnscpp_type argumentsjoinrname)r8rGZcpp_argsZ cpp_args_strZsig_declr:r:r?_sig_decl_wrapper:s rN)r8fbackend_indicesr9c st|dksjrdSfdd|D}d}t|dkr|d}|rddd |D}d |jd |jd |d }ndjjdt|d}dj d jdt |d|d S)a For a given `NativeFunction`, find out the corresponding native function and dispatch to it. If zero or more than one native function exists, error out. A simplified version of register_dispatch_key.py Arguments: sig: A CppSignature for this native function we want to use. f: NativeFunction to generate static dispatch. backend_indices: All available backends. Return: C++ code to call backend-specific functions, e.g., "return at::native::add(self, other, scale);" rcsg|]}|r|qSr:)Z has_kernel)r=brOr:r?r@\s z#static_dispatch..NrAcss|] }|jVqdSNrMr<r:r:r? asz"static_dispatch..z return ::::rCz);zH ET_ASSERT_UNREACHABLE_MSG("The number of native function(s) binding to z is z .");  //  TORCH_API inline z { z } ) lenZmanual_kernel_registrationZ get_kernelrLrK cpp_namespacekernelrHrM namespacerN)r8rOrPbackendsZ static_blockbackend_metadataargsr:rSr?static_dispatchJs. rbT)frozenc@sTeZdZUeeed<eed<eed<ee gefed<e e e e dddZ dS) ComputeFunctionstatic_dispatch_backend_indicesselector use_aten_lib is_custom_oprOr9cCs|j|jd|jjs dStj|jkr0dS|jrLt j |d|j d nt |}|jr||sd}d|jd|jdt|d|d|d d |Dd St|||jd SdS) NrXFmethodZfallback_bindingrArYrZz { return at::rCcss|] }|jVqdSrUrVr=er:r:r?rWsz+ComputeFunction.__call__..z); } )rP)rfis_root_operatorr^rHrMr1functionvariantsrgrfrom_native_functionmanual_cpp_bindingmost_faithful_signaturerrhrNrLrKrbre)selfrOr8commar:r:r?__call__|s<  zComputeFunction.__call__N)__name__ __module__ __qualname__rr(__annotations__r2boolrr.rrstrrvr:r:r:r?rdrs  rdc@sBeZdZUeed<eed<eeeee e ffe dddZ dS)ComputeCodegenUnboxedKernelsrfrg)unbox_kernel_entryr9c s|d|dd}|dd}jdjj}|j|sDdSt|tsT|g}|j|dd|D}|stdS|jrt j dj d }t j}t j}|} d jd|n4t }tj}tj}|jdd } |jd|jt|d | \} d d } | dd| DtjjdkrtjjjdkrZtdjdjjjd} dt| d| jddnBtjjjdkrdt| d|jjdnddddfdd|DS)NrrTrXrQcSsg|] }|qSr:)to_native_stringr=kr:r:r?r@sz9ComputeCodegenUnboxedKernels.__call__..Frjztorch::executor::)include_context)argument_type_genz rAcss|] }|jVqdSrUrVrlr:r:r?rWsz8ComputeCodegenUnboxedKernels.__call__..zCan't handle native function z with no returns and no out yet.zstack[z] = &;z*stack[z] = EValue(result_);z result_ = z  csxg|]p}djdjjd|dkr4d|dnddtddjjd d d d qS) z Kernel( "rXz",default"rQz [](z, EValue** stack) { z- EXECUTORCH_SCOPE_PROF("native_call_z "); z (context, z ); z } ), )r^rHrMrZdefnrLrargs_strZcode_connectorZ code_listrOZ kernel_callnewlineZ ret_prefixZreturn_assignmentr:r?r@s, )r^rHrMrfrnrElistZet_get_selected_kernelsrgrrqrrrsrFZargumenttype_typerGrKrrr\r]rZconvert_argumentsrLr[rIout ExceptionrJ) rtr~ kernel_keyZ kernel_metaop_nameZused_kernel_keysr8rZreturn_type_genrKZ binding_listZ arg_connectorrr:rr?rvsr         z%ComputeCodegenUnboxedKernels.__call__N) rwrxryr2rzr{rr r.rr)r|rvr:r:r:r?r}s r})native_functionscpu_fmrfrg kernel_indexr9csltttttfftddd}fdd|Dr:dndg|jd|fd d d d d hddS)N)itemr9cSs|djd|ddS)Nr:rT)Z root_namer)rr:r:r?key_funcszgen_unboxing..key_funccs0g|](}|D]\}}|||ffqqSr:) get_kernelsitems)r=native_functionrmetadata)rr:r?r@sz gen_unboxing.. Functions.hNativeFunctions.hz!RegisterCodegenUnboxedKernels.cppcs&t|g|dkrngdS)Nr)unboxed_kernels fn_header)r})r~)headerrrfrgr:r?s   zgen_unboxing..rTrr)Zkey_fnZ env_callableZ num_shardsZ sharded_keys)r r.rr)r|Z write_sharded)rrrfrgrrr:)rrrrfrgr? gen_unboxings   r)grr9csdt|tsttj|d||dkr4gSdttt dfdd fdddDS) NrSZ TORCH_API)rrr9csdj|j|ddS)NrB)rMrr)r;r])rr)prefixr8r:r?gen_decl-sz5compute_native_function_declaration..gen_declcs g|]}D]}||q qSr:r:)r=rr)r metadata_listr:r?r@0sz7compute_native_function_declaration..)FT) rEr.AssertionErrorrrqrvaluesr)r{r|)rrr:)rrrr8r?#compute_native_function_declaration s  rcustom_ops_native_functions)rrrfrgrr9c stj}|}tt}|D]}||j|qd} d} |D]`} t| ddd} ttt |g||fddd|| } | d| j d| | 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. rQr)Z namespace_str entity_nameZ max_levelcsdk o|kSrUr:rSrr:r?r`sz,gen_functions_declarations..)rerfrgrhz ) r+CPU_to_backend_indexrrr^appendr7r6rdZprologuerLepilogue)rrrfrgr dispatch_keyZ backend_indexZns_grouped_functionsrZfunctions_declarationsrr^Z ns_helperZ declarationsr:rr?gen_functions_declarations7s@   r)rrnative_function_decl_genr9c Cs|tt}|D]j}t}||}|D]L}|rB|j}||nt}t|dks`t d||| |||q(q |S)NrTz6Codegen only supports one namespace per operator, got ) rrsetrrr\addr*r[rextend) rrrns_grouped_kernelsrOZnative_function_namespacesZ op_kernelsr`r^r:r:r?get_ns_grouped_kernelsns"     r)rgen_custom_ops_headerrrfrrrgr9c sdgtji|r:|ddfddd|dfddd d d d gir|dfd dn$ttd|dfdddS)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.hrcsttjdddgdS)NZgrouped_native_functionsrPrz#include z#include )nativeFunctions_declarationsheaders)r#r rr:)rPrr:r?rszgen_headers..%#include "CustomOpsNativeFunctions.h"rcs"rndgtddS)Nz#include "NativeFunctions.h")rrrfrgr)Zstatic_dispatch_extra_headersZFunctions_declarations)rr:) aten_headersrrrrfrgr:r?rsrzK#include // at::Tensor etc.z3#include // TORCH_APIz=#include cstdttjdifS)Nrr)dictr#r rr:)rPrrr:r?rs)rrrcstdtdifS)Nr)r)rr$r:)rrr:r?rsN)r+rrwrite_with_templaterwriterrrrrrfrrrgr:) rrPrrrrrrfrgr? gen_headerssB   r)rrfrrrocmr9cstjt|||d\|dddfdd|dddfddt|d \|d fd ddS) N)rrfrrZRegisterz CustomOps.cppz RegisterDispatchKeyCustomOps.cppcsdddS)NrrQZ ops_headersr+Zdispatch_namespaceZdispatch_namespaced_definitionsZdispatch_anonymous_definitions"static_init_dispatch_registrations)lowerr:)anonymous_definitionrrr:r?rsz gen_custom_ops..zStub.cppcs"ddtttdS)NrQr)rrr6rr:)rrrr:r?r s )rZschema_selectorzRegisterSchema.cppcs dS)N)schema_registrationsaten_schema_registrationsr:r:)rrr:r?r!s)r+rrrr%rrrfrrrr:)rrrrrrr?gen_custom_opss>    r)tags_yaml_pathaten_yaml_pathnative_yaml_pathrgout_filer9c s|r*t|}||W5QRXdSt||ddd\}}dd|D}dd|Ddd|D} fdd|D} |rtj|rt|j d krdSt|(} t j | t d } | sW5QRdS| D]} t | d tst| t|| d tfd d d| kr*d| d<d| kr@W5QRqt | dtsZt| | d}d|krvd|}|| kst| || d<|| kr| |D]\}}|| |<qW5QRXqt j| |ddW5QRXdS)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_gencSs$i|]}|j|jd|jjqS)rX)rHr^rMr=rOr:r:r? ^sz)translate_native_yaml..cSsi|]\}}|j|qSr:rVr=rHrMr:r:r?rascSsi|]\}}|t|qSr:)r|rr:r:r?rescsi|]\}}||qSr:r:)r=opv)op_to_scoped_namer:r?rfsrLoaderZ__line__cs ddS)Nzin z: r:r:)locr:r?rwz'translate_native_yaml..rprorHrrXzaten::i)width)open writelines readlinesr rospathexistsstatst_sizeyamlloadr&rEgetintrr-popr3r|dump)rrrrgrZ aten_yamlrZpersisted_fieldsZfunc_to_scoped_nameZ schema_dictZkernel_persist_dictZ native_yamlZ native_esrmopnamerrr:)rrr?translate_native_yaml(sb*           rF)rrfunction_filterrr9c s4|r(tj|r(t|jdkr(t|}tj|td}W5QRXt dd|Drbt |nd}|D]}t D]}| |dqrqjt ||d||d} tt|| j} dd| D|dk rfdd |jD} | t| d fStttftttfd fd d fdd | jD} | | fSgifSdS)Nrrcss|]}d|kVqdS)ZkernelsNr:rlr:r:r?rWszparse_yaml..)rZ loaded_yamlcSsg|] }|jjqSr:)rHrMrr:r:r?r@szparse_yaml..csi|]\}}|kr||qSr:r:)r=rZkernel_mappingop_namesr:r?rszparse_yaml..index)mr9csfddDS)Ncsi|]}|kr||qSr:r:)r=r)rrr:r?rsz1parse_yaml..map_index..r:rrrr? map_indexszparse_yaml..map_indexcsi|]\}}||jqSr:r)r=rrR)rr:r?rs)rrrrrrrrr&anyr!rrr'rfilterrrrrrr0r)rP) rrrrrOesrentryfield parsed_yamlrZfiltered_indexrPr:)rrr? parse_yamls< &     r)rrrcustom_ops_yaml_pathrfrgr9c sddl}ttdfdd }|}tj|d} t| d} t||||| W5QRXt | ||| \} } t |||d\} }t | t st | } t |t st |}| | }t | |}t||}t| |}W5QRX||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. rNrics |SrU)Zis_native_function_selectedrSrfr:r?rsz)parse_yaml_files..function_filterztranslated.yamlwT)tempfiler.r{TemporaryDirectoryrrrLrrrrErZfrom_backend_indicesZ merge_indicesr)rrrrrfrgrrZ tmpdirnameZtranslated_yaml_pathZ translatedZtranslated_functionsZtranslated_indicesZcustom_ops_functionsZcustom_ops_indicesZcombined_functionsZcombined_kernel_indexZ combined_yamlcustom_ops_parsed_yamlr:rr?parse_yaml_filessH       r)r9c Cs6tjdd}|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|}|jstd4t|j|j }t |j |j|j |j ||jd5\}}|j|j}}|rd|jng}t|d6}d0|jkrt||j |||||jd7d1|jkrt||||j|d8|rt|||||jd9|jr2t|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)rrz-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 --generatersourceszGenerate only a subset of files)typerchoicesrrz.tags.yaml is required by codegen yaml parsing.)rrrrrfrg)optionsr)rrrfrgrrrQ)argparseArgumentParser add_argumentr| parse_argsZ tags_pathrr"Zop_registration_whitelistZop_selection_yaml_pathrrZfunctions_yaml_pathrrgrrr5generaterrrrZoutput_dependenciespathlibPathresolverMstemparentZ write_outputs)parserr rfrrrrrrZ depfile_pathZ depfile_nameZ depfile_stemfmrvarnamerr:r:r?main s        r__main__)F)]r rr collectionsr dataclassesrtypingrrrrrr r r r rZtorchgenr Z torchgen.apirrFZtorchgen.api.typesrrrrZtorchgen.contextrrrZtorchgen.executorch.apirZ"torchgen.executorch.api.custom_opsrrZtorchgen.executorch.api.typesrrZ torchgen.executorch.api.unboxingrZtorchgen.executorch.modelrrrZtorchgen.executorch.parserr r!Z torchgen.genr"r#r$r%r&r'Ztorchgen.modelr(r)r*r+r,r-r.r/r0r1Z!torchgen.selective_build.selectorr2Ztorchgen.utilsr3r4r5r6r7r|rNrbrdr}r{rrrrrrrrrrrwr:r:r:r?s  ,     0    ()^ '   9  ! ` > g  : F%