o <&izt@sddlZddlmZddlmZddlmZmZmZm Z m Z m Z ddl m mZddlmZmZmZmZmZmZddlmZddlmZmZmZmZmZmZmZm Z ddl!m"Z"dd l#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.d ed e/fd dZ0ded e/fddZ1dede eefde/d e/fddZ2ded e/fddZ3ded e e/eeffddZ4eddGdddeZ5eddGddde5Z6eddGd d!d!Z7Gd"d#d#Z8eddGd$d%d%Z9d&eee/efd'e5d ee/fd(d)Z:dS)*N)ABC) dataclass)AnyDictListOptionalTupleUnion) getValueT isValueType LazyArgumentLazyIrProperties LazyIrSchematensorListValueT) translate) BaseCTypeBindingdeviceTDispatcherSignaturekernel_signatureNativeSignature OptionalCType VectorCType)method_with_native_function)ts_lowering_body) Argument BackendIndexBackendMetadataBaseTyBaseTypeFunctionSchemaListTypeNativeFunctionNativeFunctionsGroupargreturncCst|jrbt|jtr2|jrd|jS|jjtur!d|jdS|jr+d|jdSd|jdSt|jt rY|jrE|jd|jdS|jrNd|jSd|jd |jd St d |jdt|j t r|j j ttjkr|jr{d |jdSd |jd|jdSt|jtrt|jj trd|jj jd|jd|jdSt|jt rt|jj trt|jj j trd|jj j jd|jdS|jS)z Given a LazyArgument, generate a c++ string for materializing an rvalue of that arg for passing into a lazy Node constructor. Znode_lazy_Z _tensorlistzGetSymIntValue()z->GetIrValue()z& ? c10::make_optional(GetSymIntValue(*z)) : c10::nulloptz ? c10::make_optional(lazy_z->GetIrValue()) : c10::nullopt=TODO not sure if there are other valid types to handle here (zGetSymIntArrayRefValue(zstd::vector(z .begin(), z.end()) std::vector<>(ztorch::lazy::ToOptionalVector<)r lazy_type isinstanceris_wrapped_scalarnametyperis_symint_or_listrAssertionError orig_typer!elemrrZSymIntsymintr)r$r5@C:\wamp64\www\opt\env\Lib\site-packages\torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_string)sN        "  r7schemacCsdd|D}d|S)zg Produce a formatted string with the arguments as passed into the constructor of a node class. cSsg|]}t|qSr5)r7.0r$r5r5r6 hsz$node_ctor_inputs.., ) filtered_argsjoin)r8Znode_ctor_valuesr5r5r6node_ctor_inputsds r?sig overload_namecCszt|j}t||}ddd|D}t|r(d|jd|d}nd|jd}dt|d |d |d S) zK Generate code that falls back to eager conditioned on a predicate z, cSg|]}|jqSr5exprr:ar5r5r6r;xz%gen_fallback_code..z ATEN_OP2(r<r'zATEN_OP(z" if (force_eager_fallback(zQ)) { return at::native::call_fallback_fn_symint<<c_eager_fallback, z>::call( z ); } ) r from_schemafuncr argumentsr>len aten_name aten_symbol)r8r@rAdispatcher_sigexprsZ fallback_argsZ aten_op_strr5r5r6gen_fallback_codens rPcCs<dh}|j|vrd|jdS|jdsd|jS|jS)NZsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z at::aten::)rL startswith)r8Zmissing_interned_stringsr5r5r6rMs   rMcCsg}g}|D]/}t|jtr2|jjr2|jd}|d|d|jd|||q||qd |}||fS)N_metazauto z = to_meta(); ) rJr,Zargumentrr/Zis_tensor_liker.append with_namer>)r@contextZunwrapped_tensor_argsr$Zunwrapped_nameZunwrap_tensor_args_strr5r5r6convert_to_meta_tensorss    rXT)frozenc@seZdZUeed<eed<eed<eed<edee e fde efddZ d e defd d Zd e d edefd dZd e d edefddZd e defddZd e de efddZdS) GenLazyIR backend_index backend_name node_baseuse_lazy_shapefr%cCsVt|tr |jjn|j}|jt|tr|jn|}t||duo#|d}||S)Nr4) r,r#Z functionalrIr[ get_kernelrsupports_symintgen)selfr_rImetadatar8r5r5r6__call__s zGenLazyIR.__call__r8cCdSNr5)rdr8r5r5r6lowering_functionzGenLazyIR.lowering_functionnode_ctor_argscCrgrhr5rdr8rlr5r5r6create_functionrkzGenLazyIR.create_functioncCs d|dS)Nbool CanBeReused(z!) const { return false; }r5rmr5r5r6can_be_reused_function z GenLazyIR.can_be_reused_functionc Csp|jddd}g}|D]*}t|jttfr||jq t|jtr-||jdq td|jdd |}|jddd}|j j rId}nL|j j rld d |D}| d d |Dd |jdd |d}n)|j jrdd tt|D}| dd |Dd|jdd |d}nd}d dd |D} |jd|jd|d|dt|jd| d S)NTFvaluesZscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryr<zstd::move(shapes),cSrBr5r.rEr5r5r6r;rGz1GenLazyIR.node_base_ctor_call..cs|]}|jVqdSNrurEr5r5r6 z0GenLazyIR.node_base_ctor_call..Zcompute_shape_(z),cSg|]}d|dqS)zoperand(r'r5r:ir5r5r6r;csrvrwrurEr5r5r6rxryz[&](){ return compute_shape_z)[0]; },ricss|]}|jVqdSrwrurEr5r5r6rxsz( z&::ClassOpKind(), OpList{z}, z! /* num_outputs */ z#, torch::lazy::MHash()))r=r,r+rrrUr.rr1r> propertiesShapePrecomputeZ ShapeComputeextend ShapeCacherangerKr] node_namereturns) rdr8 value_argsZbase_ctor_value_args_listr$Zbase_ctor_value_args scalar_argsZshape_ctor_argZ shape_argsZ scalar_hashesr5r5r6node_base_ctor_callsF   zGenLazyIR.node_base_ctor_callcCs|jpt|}|}|jddd}|jddd}dd|D}d|}|jr1|jjr1|dd|}dd d|D} t| rId| } d d d|D} d d|jdddD} d d d| D} ddd| D} g}|D]7}t |j t r|j d}|j rd}|d|j d|j d|d|j d qw|d|j d|j dqwd|}d|jd|jd|d|jd|d||| d| d |jd!|d"|||d#|||d#||d#| d | d$gS)%NTFrrcSs$g|]}d|jd|jqS)zconst z& r+Zcpp_typer.r|r5r5r6r;s$z!GenLazyIR.gen..r<z(std::vector&& shapesz , cSsJg|]!}|jdkr|jd|jd|jdn |jd|jdqS)c10::optionalrzz/.has_value() ? c10::make_optional(std::string(*z)) : c10::nullopt)r'rrEr5r5r6r;s z cSs\g|]*}|jdkrd|jdn|jdkr d|jdn |jd|jdqS)zc10::string_viewz std::string ;rzc10::optional  rrEr5r5r6r; scSsg|] }t|jtr|jqSr5)r,r+rr.r9r5r5r6r;s  cSr{)z bool has_z: 1;r5r:valuer5r5r6r;r~z cSsg|] }d|d|dqS)Zhas_z = !!rr5rr5r5r6r;sz.value()z"torch.Generator()"zif (z.has_value()) { ss << ", z=" << z; } else { ss << ", z =null"; }z ss << ", rzclass z : public zX { public: static torch::lazy::OpKind ClassOpKind() { return torch::lazy::OpKind(z ); } rzz ) : z { zT } std::string ToString() const override { std::stringstream ss; ss << z::ToString(); z return ss.str(); } z z }; )opkindrMr=r>r^rrrUrKr,r+rr.Z is_generatorrr]rrnrprj)rdr8rall_argsrrZ ctor_argsZreuse_ctor_argsrlZscalar_initializersZ scalar_declsZoptional_valuesZhas_optional_declsZhas_optional_defsZmembers_to_stringr$rZmembers_to_string_strr5r5r6rcs              z GenLazyIR.genN)__name__ __module__ __qualname__r__annotations__strboolrr r#r"rrfrrjrnrprrcr5r5r5r6rZs   *rZc@sJeZdZdedefddZdededefddZdededefdd Zd S) GenTSLazyIRr8r%cCs6d}|jjr |dS|jjr|dt|dSdS)Nz torch::lazy::TSOpVector Lower( std::shared_ptr function, torch::lazy::TSLoweringContext* loctx) const overriderz { z } ri)r LowerDeclOnlyZLowerr)rdr8 signaturer5r5r6rjUs zGenTSLazyIR.lowering_functionrlcCs<d|d}|jjr|dS|jjsdS|d|jdS)Nzstatic NodePtr Create(r'rriz { return ReuseOrMakeNode(data); })rZCreateFnDeclOnlyZCreateFnr)rdr8rlrr5r5r6rnes  zGenTSLazyIR.create_functioncCs d|d}|jjr|dS|jjsdSg}t|j|jD]}t|jt r2| d|j dq| d|j qt|j |j D]4}t|jt rk| d|j d |j d |j d |j d |j d |j d qD| d|j d|j qDd|}|d|dS)Nroz) constrriznullable_operand(i++) == rtzoperand(i++) == z ((!this->z&&!z ) || (this->z&&z && *(this->z) == *rzthis->z == z && z! { size_t i = 0; return (z); })rZCanBeReusedDeclOnly CanBeReused itertoolschainZpositional_valuesZkeyword_valuesr,r+rrUr.Zpositional_scalarsZkeyword_scalarsr>)rdr8rlrZvalue_comparisonr$Zvalue_comparison_strr5r5r6rpos,     4 z"GenTSLazyIR.can_be_reused_functionN)rrrrrrjrnrpr5r5r5r6rSs rc @sbeZdZUeed<eed<eed<eed<eed<eed<eed<eed<eed <eed <eed <eed <eed <eed<eed<dededefddZ dedede de e e fdef ddZdededefddZdededefddZdededefddZdededefdd Zd)d"eedefd#d$Zdededefd%d&Zededeefd'd(Zd!S)*GenLazyNativeFuncDefinitionclass_method_namer[ tensor_classgen_forced_fallback_codebackend_namespaceget_tensorlistget_tensor_or_wrap_numbertry_get_tensormetrics_counter create_tensorcreate_from_first_tensorcreate_aten_from_ltc_tensortuple_aten_from_ltc_tensorslazy_tensor_ptr get_device_fnrIr8r%c Csl|jddd}g}|D]}|jr8t|jtr)|d|jd|jd|jdq |d|jd|jd q |jr GetIrValueForScalarFromCodegen(*z1, *common_device)): c10::nullopt;zf = torch::lazy::LazyGraphExecutor::Get()-> GetIrValueForScalarFromCodegen(z, *common_device);z auto lazy_z_tensorlist = ::rzrSz lazy_z.value_or(at::Tensor()));r(r'rT)r=r-r,r+rrUr.r0rr/rrrrrr3r rr1r>)rdrIr8rlazy_tensor_declsr$r5r5r6rsh        z-GenLazyNativeFuncDefinition.lazy_tensor_declsrer@cCs|jr t|||jjjdSdS)N)rAri)rrPrIr.rA)rdrIr8rer@r5r5r6force_eager_fallbacks  z0GenLazyNativeFuncDefinition.force_eager_fallbackcCs |jdS)Nr)r)rdrIr8r5r5r6metricsrqz#GenLazyNativeFuncDefinition.metricscs|jddd}|jddd}dd|D}tttfdd|D}t|dks4t|dks4Jd|jd d ||d }d |d S)NTFrrcSg|] }|js|jqSr5r-r.rEr5r5r6r;z:GenLazyNativeFuncDefinition.get_device..csg|] }|jkr|jqSr5)r+r.rEZoptional_devicer5r6r;srz*Expected at least one Value or Device typerzr<r'zauto common_device = z8; TORCH_INTERNAL_ASSERT(common_device); )r=rrrrKrr>)rdrIr8rrvalue_types_namesZoptional_devicesZget_device_strr5rr6 get_devices   z&GenLazyNativeFuncDefinition.get_devicec s|j|}|dus J|}t|j}d|jv}|jp!|jdu}|s&|rd}|dkrIdtdt fddd fd d t |D} d | d }t |j} t| \} } d d t| | ddD} |rm|jsjJd}nd}|j}|jr|r|d7}d| d|d|dd | d| }nt|j||d}d|jd}|d|d7}dt |j}|dd d d!|Dd"|d#7}|S)$N view_copyzl std::vector shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};r}r%cSsd|d|dS)Nztorch::lazy::Shape(std::get(out_meta).scalar_type(), std::get(out_meta).sizes().vec())r5)r}r5r5r6 this_shapesz?GenLazyNativeFuncDefinition.shape_inference..this_shape,csg|]}|qSr5r5r|rr5r6r;z?GenLazyNativeFuncDefinition.shape_inference..z'std::vector shapes{z};cSrBr5rC)r:er5r5r6r;sF)methodZ&compositeexplicitautogradnonfunctionalmetaZ_symintz z auto out_meta = at::rrzr<z ); r`z auto shapes = rz4 TORCH_INTERNAL_ASSERT(shapes.size() == rSzaten::zq if(torch::lazy::symbolicShapeEnabled()){ std::vector inputs = { css|]}t|jVqdSrw)rr.rEr5r5r6rx1sz>GenLazyNativeFuncDefinition.shape_inference..z. }; const char* schema_str = "z^"; applySymbolicShapesOnLT(schema_str, inputs, shapes); } )r[rar=rKrtags structuredstructured_delegateintrr>rrrHrIrXrrJZ5has_composite_explicit_autograd_non_functional_kernelrLZ has_symintrbComputeShapeSignaturekernel shape_call)rdrIr8rerreturns_lengthis_view_copy_op is_structuredZmeta_outZ shapes_strrNZmeta_conversion_strZ meta_call_ctxZmeta_call_argsZ dispatch_nsrLZ shape_str shape_sigZfunc_schema_strr5rr6shape_inferencesj            z+GenLazyNativeFuncDefinition.shape_inferencec Cs8t|}d|jd|d|||d|jd|d S)Nz3torch::lazy::NodePtr node = torch::lazy::ReuseNode.rzauto result = z( z#(std::move(node), *common_device));rz3Code below assumes there is at least one tensor argr)z,> lazy_tensors; for (int i = 0; i < z,; i++) { lazy_tensors.push_back(rzz=(node, i), *common_device)); } auto result = (lazy_tensors);zqWe assumed there was no such case where an op is an in-place variant and has tuple outputs, but got tuple of len rr&z2->SetInPlaceIrValue(node); auto& result = rz return result;) rKrr=rrrr rr.ZinplacerIZ is_out_fn)rdrIr8rrrrZ bridge_strr5r5r6return_aten_tensorLsB    z.GenLazyNativeFuncDefinition.return_aten_tensorcCst||j}|j|}|dusJt|j|d}d|j|jd|jdd| ||||d| ||d| ||d| ||d| ||d|||dgS)Nr`z rruz { rTz } )rr[rarrIrbdeclrrrrrrrr)rdrIr@rer8r5r5r6rfjs(        z$GenLazyNativeFuncDefinition.__call__rw)rrrrrrrr"rrrr rrrrrrrrrrrrrfr5r5r5r6rsH -   K  rc@sfeZdZdZdededefddZdefdd Zdefd d Z e defd d Z e defddZ dS)rzm Here we use the base name as the suffix of the signature to avoid generating for in-place variants. kernel_namer_r4cCs\t|j|d|_dddtj|j|dD|_ddd|jjddD|_||_ dS)Nr`r<cSsg|]}|qSr5)rrEr5r5r6r;rz2ComputeShapeSignature.__init__..cSsg|]}|jqSr5rur9r5r5r6r;rT) generator) rrIZ_ComputeShapeSignature__schemar> dispatcherrJ%_ComputeShapeSignature__dispatch_argsr=!_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)rdrr_r4r5r5r6__init__s zComputeShapeSignature.__init__r%cC|jd|jdSNrzr')rrrdr5r5r6Z __decl_suffixz#ComputeShapeSignature.__decl_suffixcCrr)rrrr5r5r6Z __call_suffixrz#ComputeShapeSignature.__call_suffixcCd|S)Nz8TORCH_API std::vector compute_shape_)#_ComputeShapeSignature__decl_suffixrr5r5r6 shape_declz ComputeShapeSignature.shape_declcCr)Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixrr5r5r6rrz ComputeShapeSignature.shape_callN) rrr__doc__rr"rrrrpropertyrrr5r5r5r6r~s rc@s8eZdZUeed<eed<ededeefddZ dS)GenLazyShapeInferenceDefinitionr[rr_r%cCstt||j}|j|}|dusJd|jv}|jp|jdu}|s#|r%gSt|j||d}d |j dggS)Nrr` r) rr[rarrrrrrbr>r)rdr_r@rerrrr5r5r6rfs     z(GenLazyShapeInferenceDefinition.__call__N) rrrrrrrr"rrfr5r5r5r6rs r non_native gen_lazy_ircCstg}|D]3}tddd}|dgD]}t||dqtt|d|dd}|d|_|||d q|S) z,Generate the non-native lazy IR node classesrrrrTrIr`rr) r getsetattrrr parserrUrc)rrnodesoprpr8r5r5r6!generate_non_native_lazy_ir_nodess  r);rabcr dataclassesrtypingrrrrrr Ztorchgen.api.dispatcherapirZtorchgen.api.lazyr r r r rrZtorchgen.api.translaterZtorchgen.api.typesrrrrrrrrZtorchgen.contextrZtorchgen.dest.lazy_ts_loweringrZtorchgen.modelrrrrrr r!r"r#rr7r?rPrMrXrZrrrrrr5r5r5r6sT     ( , ;   -8r