
    '}hq                     R   d dl Z d dlmZ d dlmZ d dlmZmZmZm	Z	m
Z
mZ d dlmc mZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZmZm Z  d dl!m"Z" d d	l#m$Z$ d d
l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. dede/fdZ0dede/fdZ1dedeeef   de/de/fdZ2dede/fdZ3dede
e/ee   f   fdZ4 ed       G d de             Z5 ed       G d de5             Z6 ed       G d d             Z7 G d d      Z8 ed       G d d              Z9d!eee/ef      d"e5dee/   fd#Z:y)$    N)ABC)	dataclass)AnyDictListOptionalTupleUnion)	getValueTisValueTypeLazyArgumentLazyIrPropertiesLazyIrSchematensorListValueT)	translate)	BaseCTypeBindingdeviceTDispatcherSignaturekernel_signatureNativeSignatureOptionalCTypeVectorCType)method_with_native_function)ts_lowering_body)	ArgumentBackendIndexBackendMetadataBaseTyBaseTypeFunctionSchemaListTypeNativeFunctionNativeFunctionsGroupargreturnc                    t        | j                        r t        | j                  t              rs| j                  rd| j
                   S | j                  j                  t        u rd| j
                   dS | j                  rd| j
                   dS d| j
                   dS t        | j                  t              r`| j                  r| j
                   d| j
                   dS | j                  rd| j
                   S d| j
                   d	| j
                   d
S t        d| j                   d      t        | j                  t              ri| j                  j                  t        t        j                         k(  r9| j"                  rd| j
                   dS d| j
                   d| j
                   dS t        | j                  t$              rbt        | j                  j                  t              r>d| j                  j                  j                   d| j
                   d| j
                   dS t        | j                  t              rt        | j                  j                  t$              rit        | j                  j                  j                  t              r;d| j                  j                  j                  j                   d| j
                   dS | j
                   S )z
    Given a LazyArgument,
    generate a c++ string for materializing an rvalue of that arg for passing into
    a lazy Node constructor.
    node_lazy__tensorlistzGetSymIntValue()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 (zGetSymIntArrayRefValue(zstd::vector<int64_t>(z
.begin(), z.end())std::vector<>(ztorch::lazy::ToOptionalVector<)r   	lazy_type
isinstancer   is_wrapped_scalarnametyper   is_symint_or_listr   AssertionError	orig_typer"   elemr    r   SymIntsymintr   )r%   s    T/var/www/html/test/engine/venv/lib/python3.12/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_stringr;   )   sn    3==!cmmY/$$sxxj))##'77sxxj44&&(
!44388*N33}5$$ ((#I#((Sdee&&sxxj))z "++.88* 5 !OPSP]P]^_`  cmmX.3==3E3EMMJ
 4
 zz0
!<<.sxxj
388*GTT{3
MM	9
 "#--"4"4"9"9!:"SXXJjQTQYQYPZZabbs}}m43==--{;3==--22I>3CMM4F4F4K4K4P4P3QQSTWT\T\S]]^__hhZ     schemac                 z    | j                         D cg c]  }t        |       }}dj                  |      S c c}w )zg
    Produce a formatted string with the arguments as passed into the constructor of a node class.
    , )filtered_argsr;   join)r=   r%   node_ctor_valuess      r:   node_ctor_inputsrC   d   sE    
 5;4H4H4J-0#C(  99%&&s   8sigoverload_namec                 t   t        j                  | j                        }t        |j	                         |j	                               }dj                  |D cg c]  }|j                   c}      }t        |      rd| j                   d| d}nd| j                   d}dt        |        d| d| d	S c c}w )
zK
    Generate code that falls back to eager conditioned on a predicate
    z,
                z	ATEN_OP2(r?   r+   zATEN_OP(z"
        if (force_eager_fallback(zQ)) {
            return at::native::call_fallback_fn_symint<&ltc_eager_fallback, z>::call(
                z
            );
        }
)
r   from_schemafuncr   	argumentsrA   exprlen	aten_nameaten_symbol)r=   rD   rE   dispatcher_sigexprsafallback_argsaten_op_strs           r:   gen_fallback_coderS   n   s     )44V[[ANcmmo~'?'?'ABE)../F1/FGM
=!&"2"2!32m_AF !1!1 2!4""-f"5!6 7MMXM Z    0Gs   B5c                     dh}| j                   |v rd| j                    dS | j                   j                  d      sd| j                    S | j                   S )Nsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rL   
startswith)r=   missing_interned_stringss     r:   rM   rM      sh      334V5E5E4FbII&&v.F,,-..r<   c                    g }g }| j                         D ]  }t        |j                  t              rv|j                  j                  j                         rR|j                   d}|j                  d| d|j                   d       |j                  |j                  |             |j                  |        dj                  |      }||fS )N_metazauto z = to_meta();	
        )
rI   r0   argumentr   r3   is_tensor_liker2   append	with_namerA   )rD   contextunwrapped_tensor_argsr%   unwrapped_nameunwrap_tensor_args_strs         r:   convert_to_meta_tensorsrd      s    G')}}  cllH-#,,2C2C2R2R2T #z/N!(('{388*B? NN3==89NN3  *../DE!7**r<   T)frozenc                       e Zd ZU eed<   eed<   eed<   eed<   edee	e
f   dee   fd       Zdedefd	Zded
edefdZded
edefdZdedefdZdedee   fdZy)	GenLazyIRbackend_indexbackend_name	node_baseuse_lazy_shapefr&   c                 8   t        |t              r|j                  j                  n|j                  }| j                  j                  t        |t              r|j                  n|      }t        ||d uxr |j                               }| j                  |      S )Nr9   )	r0   r$   
functionalrH   rh   
get_kernelr   supports_symintgen)selfrl   rH   metadatar=   s        r:   __call__zGenLazyIR.__call__   s    $.q2F$Gq||  QVV%%00&q*>?ALLQ
 -L(2J2J2L
 xxr<   r=   c                      yN  )rs   r=   s     r:   lowering_functionzGenLazyIR.lowering_function       r<   node_ctor_argsc                      yrw   ry   rs   r=   r|   s      r:   create_functionzGenLazyIR.create_function   r{   r<   c                     d| dS )Nbool CanBeReused(z!) const {
    return false;
    }ry   r~   s      r:   can_be_reused_functionz GenLazyIR.can_be_reused_function   s    $^$4 5 
 	
r<   c                 N   |j                  dd      }g }|D ]  }t        |j                  t        t        f      r|j                  |j                          @t        |j                  t              r|j                  |j                   d       yt        d|j                   d       dj                  |      }|j                  dd      }|j                  j                  rd}n|j                  j                  rT|D cg c]  }|j                   }	}|	j                  d	 |D               d
|j                   ddj                  |	       d}nx|j                  j                  r`t        t!        |            D 
cg c]  }
d|
 d
 }	}
|	j                  d |D               d|j                   ddj                  |	       d}nd}dj                  d |D              }| j"                   d|j$                   d| d| dt!        |j&                         d| dS c c}w c c}
w )NTFvaluesscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryr?   zstd::move(shapes),c              3   4   K   | ]  }|j                     y wNr2   .0rP   s     r:   	<genexpr>z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>        :aff:   compute_shape_(z),zoperand(r+   c              3   4   K   | ]  }|j                     y wr   r   r   s     r:   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   r   r   z[&](){ return compute_shape_z)[0]; },rx   c              3   6   K   | ]  }|j                      y wr   r   r   s     r:   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   s     !C!QVVH+!Cs   z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))r@   r0   r/   r   r   r^   r2   r   r5   rA   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerK   rj   	node_namereturns)rs   r=   
value_argsbase_ctor_value_args_listr%   base_ctor_value_argsscalar_argsshape_ctor_argrP   
shape_argsiscalar_hashess               r:   node_base_ctor_callzGenLazyIR.node_base_ctor_call   s   ))u)E
 %'! 	C#--)[)AB)00CHH:?CMM=9)00CHH:=R1ST$(7ST 	  $yy)BC**%*F ,,1N++*45Q!&&5J5:k::-fkk]!DIIj<Q;RRTUN))38Z3IJaHQCq/JJJ:k::<V[[M499U_K`JaajkNN		!C{!CCNN# $  !+, - !!$V^^!4 5 6""/6 	6 6 Ks   H>H"c                    |j                   xs t        |      }|j                         }|j                  dd      }|j                  dd      }|D cg c],  }d|j                  j	                          d|j
                   . }}dj                  |      }| j                  r'|j                  j                  r|j                  d       dj                  |      }	dj                  |D 
cg c]d  }
|
j                  j	                         d	k(  r)|
j
                   d
|
j
                   d|
j
                   dn|
j
                   d
|
j
                   df c}
      }t        |      rd| }dj                  |D 
cg c]  }
|
j                  j	                         dk(  rd|
j
                   dnV|
j                  j	                         d	k(  rd|
j
                   dn)|
j                  j	                          d|
j
                   d c}
      }|j                  dd      D cg c](  }t        |j                  t              r|j
                  * }}dj                  |D cg c]  }d| d
 c}      }dj                  |D cg c]  }d| d| d c}      }g }|D ]  }t        |j                  t              rZ|j
                   d}|j                  rd}|j                  d|j
                   d|j
                   d| d|j
                   d	       w|j                  d |j
                   d|j
                   d        dj                  |      }d!|j                   d"| j                    d#| d$|j                   d
|	 d%| j#                  |       | d&| d'| j                    d(| d)| j%                  ||       d*| j'                  ||       d*| j)                  |       d*| d| d+gS c c}w c c}
w c c}
w c c}w c c}w c c}w ),NTFr   zconst z& r?   z(std::vector<torch::lazy::Shape>&& shapesz
,
        zc10::optional<c10::string_view>r   z/.has_value() ? c10::make_optional(std::string(*z)) : c10::nullopt)r+   z
  zc10::string_viewzstd::string ;zc10::optional<std::string>  z	bool has_z: 1;z
    has_z = !!z.value()z"torch.Generator()"zif (z.has_value()) {
      ss << ", z=" << z;
    } else {
      ss << ", z=null";
    }z	ss << ", zclass z
 : public zX {
 public:
  static torch::lazy::OpKind ClassOpKind() {
    return torch::lazy::OpKind(z
);
  }

  z
)
      : z	
  {
    zT
  }

  std::string ToString() const override {
    std::stringstream ss;
    ss << z::ToString();
    z
    return ss.str();
  }

  z

  z

};

)opkindrM   r@   r/   cpp_typer2   rA   rk   r   r   r^   rK   r0   r   is_generatorr   rj   r   r   r   rz   )rs   r=   r   all_argsr   r   r   	ctor_argsreuse_ctor_argsr|   rP   scalar_initializersscalar_declsr%   optional_valuesvaluehas_optional_declshas_optional_defsmembers_to_stringmembers_to_string_strs                       r:   rr   zGenLazyIR.gen   ss   5+f"5 '')))u)E
**%*FJRSQvakk2245Rx@S	S))I.6#4#4#D#DGH9-+00 %
  ;;'')-NN 66(!AFF8#RSTSYSYRZZlmxq*+
 "#$/0C/D"E{{ % 	 ;;'')-?? qvvha( ;;'')-NN 3166(!<,,./q:	;	
 ++4+G
#--7 HH
 

 $[[2AByt$B
 %MM6EFUtE7%wa(F
  	RC#--788*H-##1E!((SXXJ 'zw 'z 
 "((9SXXJfSXXJa)PQ	R !).? @
4>>"2 3  !'x ( 
An% &			!	!&	)*+>*? @ 
 >>
   01 2v78 9&!" #.  7!
 !	
o T
 C Gs&   1O)+A)O.:BO3!-O8O=PN)__name__
__module____qualname__r   __annotations__strboolr   r
   r$   r#   r   ru   r   rz   r   r   r   rr   ry   r<   r:   rg   rg      s    N  % 4n DE  $s)   !   l C C 
\ 
3 
SV 

(6, (63 (6Ta
, a
49 a
r<   rg   c                   D    e Zd ZdedefdZdededefdZdededefdZy)GenTSLazyIRr=   r&   c                     d}|j                   j                  r| dS |j                   j                  r| dt        |       dS y)Nz
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider   z {
    z
  }
            rx   )r   LowerDeclOnlyLowerr   )rs   r=   	signatures      r:   rz   zGenTSLazyIR.lowering_functionU  s^    ?	
 **[?"$$!{ #f  
 r<   r|   c                     d| d}|j                   j                  r| dS |j                   j                  sy| d|j                   dS )Nzstatic NodePtr Create(r+   r   rx   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )rs   r=   r|   r   s       r:   r   zGenTSLazyIR.create_functione  sc    ,^,<A>	--[?"""++; ",,- . 	r<   c                 `   d| d}|j                   j                  r| dS |j                   j                  syg }t        j                  |j
                  |j                        D ]Z  }t        |j                  t              r |j                  d|j                   d       =|j                  d|j                          \ t        j                  |j                  |j                        D ]  }t        |j                  t              ra|j                  d|j                   d	|j                   d
|j                   d|j                   d|j                   d|j                   d       ~|j                  d|j                   d|j                           dj                  |      }| d| dS )Nr   z) constr   rx   znullable_operand(i++) == r   zoperand(i++) == z	((!this->z&&!z) || (this->z&&z && *(this->z) == *r   zthis->z == z &&
        z! {
    size_t i = 0;
    return (z);
  })r   CanBeReusedDeclOnlyCanBeReused	itertoolschainpositional_valueskeyword_valuesr0   r/   r   r^   r2   positional_scalarskeyword_scalarsrA   )rs   r=   r|   r   value_comparisonr%   value_comparison_strs          r:   r   z"GenTSLazyIR.can_be_reused_functiono  s   ''7w?	00[?"""..??6#;#;V=R=RS 	GC#--7 ''/z9NO !''*:388*(EF	G ??6#<#<f>T>TU 	KC#--7 ''zSXXJl388*BsxxjXdehememdnntuxu}u}t~  A  B !''&
$sxxj(IJ	K  /334DE; !" # 	r<   N)r   r   r   r   r   rz   r   r   ry   r<   r:   r   r   S  sJ       l C C \ 3 SV r<   r   c            
       z   e Zd ZU eed<   eed<   eed<   eed<   eed<   eed<   eed<   eed<   eed	<   eed
<   eed<   eed<   eed<   eed<   eed<   dededefdZ	dedede
deeef   def
dZdededefdZdededefdZdededefdZdededefdZd dee   defdZdededefdZededee   fd       Zy)!GenLazyNativeFuncDefinitionclass_method_namerh   tensor_classgen_forced_fallback_codebackend_namespaceget_tensorlistget_tensor_or_wrap_numbertry_get_tensormetrics_countercreate_tensorcreate_from_first_tensorcreate_aten_from_ltc_tensortuple_aten_from_ltc_tensorslazy_tensor_ptrget_device_fnrH   r=   r&   c                    |j                  dd      }g }|D ]9  }|j                  rt        |j                  t              r:|j                  d|j                   d|j                   d|j                   d       d|j                  d|j                   d|j                   d	       |j                  rt        |j                  t              r|j                  j                  t        u rH|j                  d
|j                   d| j                   d| j                   d|j                   d	       |j                  | j                   d|j                   d| j                   d| j                   d|j                   d	
       pt        |j                  t              r|j                  j                  t        t!                     k(  sJ |j                  j                         |j                  | j                   d|j                   d| j                   d| j"                   d|j                   d
       #t%        d|j                   d       dj'                  |      S )NTFr   z
auto node_z = z ?
                c10::make_optional(torch::lazy::LazyGraphExecutor::Get()->
                    GetIrValueForScalarFromCodegen(*z1, *common_device)):
                c10::nullopt;zf = torch::lazy::LazyGraphExecutor::Get()->
                            GetIrValueForScalarFromCodegen(z, *common_device);z
auto lazy_z_tensorlist = ::r   rZ   z lazy_z.value_or(at::Tensor()));r,   r+   r[   )r@   r1   r0   r/   r   r^   r2   r4   r   r3   r   r   r   r   r   r7   r   r   r5   rA   )rs   rH   r=   r   lazy_tensor_declsr%   s         r:   r   z-GenLazyNativeFuncDefinition.lazy_tensor_decls  sK   ))u)E
') &	C$$cmm];%,,&sxxjCHH: >558XXJ ?! &,,&sxxj 1<<?HH:EW[ &&CMM95==%%)99%,,$SXXJn112"T5H5H4I388*TVX
 &,,//0sxxj112"T5S5S4TTUVYV^V^U__qs CMM=9}}))Yy{-CCWS]]EWEWWC "((++,F388*C--.b1D1D0EQsxxjPik
 %STWTaTaSbbcd I&	N ""#455r<   rt   rD   c                 t    | j                   r,t        |||j                  j                  j                        S y)N)rE   rx   )r   rS   rH   r2   rE   )rs   rH   r=   rt   rD   s        r:   force_eager_fallbackz0GenLazyNativeFuncDefinition.force_eager_fallback  s4     (($499>>+G+G  r<   c                      | j                    dS )Nr   )r   )rs   rH   r=   s      r:   metricsz#GenLazyNativeFuncDefinition.metrics  s    &&'q))r<   c                    |j                  dd      }|j                  dd      }|D cg c]  }|j                  r|j                    }}t        t	        t
                    }|D cg c]  }|j                  |k(  s|j                    }}t        |      dkD  st        |      dkD  sJ d       | j                   ddj                  ||z          d}	d	|	 d
S c c}w c c}w )NTFr   r   z*Expected at least one Value or Device typer   r?   r+   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )
r@   r1   r2   r   r   r   r/   rK   r   rA   )
rs   rH   r=   r   r   rP   value_types_namesoptional_deviceoptional_devicesget_device_strs
             r:   
get_devicez&GenLazyNativeFuncDefinition.get_device  s
   ))u)E
**%*F2<XQADWDWx[XX'	'(:;'
1;;/+IAFF
 
 !"Q&#.>*?!*C	87	8C !!"!DII.?BR.R$S#TTUV 	 )(8 9	  	 Y
s   CC*C!?C!c           
      .   | j                   j                  |      }|J |j                         }t        |j                        }d|j
                  v }|j                  xs |j                  d u}|s|rd}|dkD  rFdt        dt        fd}	dj                  t        |      D 
cg c]
  }
 |	|
       c}
      }d|z   d	z   }t        j                  |j                        }t        |      \  }}t!        ||j#                         d
      D cg c]  }|j$                   }}|r|j&                  sJ d}nd}|j(                  }|j                  j+                         r|j-                         r|dz  }d| d| d| ddj                  |       d| 
}n6t/        |j0                  ||j-                               }d|j2                   d}|d| dz  }dt        |j                        z   }|ddj                  d |D               d| dz  }|S c c}
w c c}w )N	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};   r   r&   c                     d|  d|  dS )Nztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())ry   )r   s    r:   
this_shapez?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape  s    9!<`ab`cc}~~r<   ,z'std::vector<torch::lazy::Shape> shapes{z};F)method&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r   r   r?   z);
        rn   z
            auto shapes = r   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == rZ   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c              3   F   K   | ]  }t        |j                          y wr   )r   r2   r   s     r:   r   z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>1  s     FeWXs166{Fes   !z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )rh   rp   r@   rK   r   tags
structuredstructured_delegateintr   rA   r   r   rG   rH   rd   r   rI   rJ   5has_composite_explicit_autograd_non_functional_kernelrL   
has_symintrq   ComputeShapeSignaturekernel
shape_call)rs   rH   r=   rt   r   returns_lengthis_view_copy_opis_structuredmeta_outr   r   
shapes_strrN   meta_conversion_strmeta_call_ctxemeta_call_argsdispatch_nsrL   	shape_str	shape_sigfunc_schema_strs                         r:   shape_inferencez+GenLazyNativeFuncDefinition.shape_inference  sn   %%006###'')V^^, &2O4+C+C4+OOoH!# #  !XXeN>S&Tz!}&TU
DzQTXX 1<<TYYGN1H1X. #!>#;#;#=e N  QQQQF$((Iyy##%(*B*B*DY&			 (MI;a		.8Q7R S		
I
 .h.F.F.HI$//05I 	 44B3C2I 	I	 #S^3 ==AYYFe\dFe=e<f g++:*; <	 		 a 'Us   #HHc                     t        |      }d|j                   d| d| j                  ||       d|j                   d| dS )Nz3torch::lazy::NodePtr node = torch::lazy::ReuseNode<r.   z$);
        if (!node) {
            z*
            node = torch::lazy::MakeNode<zE, std::move(shapes));
            CacheNode(node);
        }
        )rC   r   r  )rs   rH   r=   node_ctor_input_strs       r:   build_ir_nodez)GenLazyNativeFuncDefinition.build_ir_node8  sf    .v6FvGWGWFXXZ[nZo p!!$/0 1**0*:*:);2>Q=R S	 	r<   Nfirst_tensor_namec                     | j                   r|J d       | d| j                   S | j                   d| j                   S )Nz+Requires first tensor to create lazy tensor.r   )r   r   r   )rs   r  s     r:   create_lazy_tensorz.GenLazyNativeFuncDefinition.create_lazy_tensorB  s[    (( "-=<=-'($*<*<)=>>(()D,>,>+?@@r<   c                    t        |j                        }|j                  dd      }|D cg c]  }|j                  r|j                    }}t        |      dkD  r|d   nd }d| j
                   d| j                  |       d}|dkD  rUt        |      dkD  sJ d	       d
| j                   d| d| j                  |       dt                d| j                   d| d}|j                  j                  j                  s|j                  j                         r|dk(  sJ d| d       d| d| d}|dz  }|S c c}w )NTFr   r   zauto result = z(
                z#(std::move(node), *common_device));r   z3Code below assumes there is at least one tensor argr-   z,> lazy_tensors;
        for (int i = 0; i < z,; i++) {
            lazy_tensors.push_back(r   z=(node, i), *common_device));
        }
        auto result = <z>(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 r  r)   z2->SetInPlaceIrValue(node);
        auto& result = r   z
        return result;)rK   r   r@   r1   r2   r   r  r   r   r   inplacerH   	is_out_fn)	rs   rH   r=   r  r   rP   r   r  
bridge_strs	            r:   return_aten_tensorz.GenLazyNativeFuncDefinition.return_aten_tensorL  s   V^^,))u)E
2<XQADWDWx[XX478I4JQ4N-a0TX'(H(H'I J(():;<<_c
 A%&*EDE*)$*>*>)? @+, -$$($;$;<M$N#OqQZQ\P] ^778.9IIY	]J ;;##tyy':':'<!Q& ??M>NaQ& ##4"5 6)*!/J 	  	
3 Ys
   D;D;c                    t        || j                        }| j                  j                  |      }|J t        |j                  |j                               }d|j                  | j                   d|j                          d| j                  ||||       d| j                  ||       d| j                  ||       d| j                  ||       d| j                  ||       d| j                  ||       dgS )Nrn   z    r   r   z {
        r[   z
    }

    )r   rh   rp   r   rH   rq   declr   r  r   r   r   r   r  r  )rs   rH   rD   rt   r=   s        r:   ru   z$GenLazyNativeFuncDefinition.__call__j  s"   tT%7%78%%006###dii0H0H0JKXXd,,-R/@AXBC D			"	"43	?@ A		dF	#$ %		v	&' (				f	-. /				D&	)* +			 	 v	./ 0	
 	
r<   r   )r   r   r   r   r   r   r   r#   r   r   r   r
   r   r   r   r   r   r  r  r   r  r  r   r   ru   ry   r<   r:   r   r     s   """"""!$$!$$+6n +6l +6s +6Z  "	
 &78 
*N *L *S *~ |  $IN IL IS IV. , 3 AHSM AS A~ | PS < !
^ 
S	 
 !
r<   r   c                   h    e Zd ZdZdededefdZdefdZdefdZ	e
defd	       Ze
defd
       Zy)r   zm
    Here we use the base name as the suffix of the signature to avoid generating for in-place variants.
    kernel_namerl   r9   c                   t        |j                  |      | _        dj                  t	        j
                  |j                  |      D cg c]  }|j                          c}      | _        dj                  | j                  j                  d      D cg c]  }|j                    c}      | _
        || _        y c c}w c c}w )Nrn   r?   T)	generator)r   rH   _ComputeShapeSignature__schemarA   
dispatcherrI   r  %_ComputeShapeSignature__dispatch_argsr@   r2   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)rs   r!  rl   r9   rP   r%   s         r:   __init__zComputeShapeSignature.__init__  s    $QVVF;#yy)33AFF6JK!QVVXK 
  99&*mm&A&AD&A&QRsz]R
 ) L Ss   B?Cr&   c                 :    | j                    d| j                   dS Nr   r+   )r(  r&  rs   s    r:   __decl_suffixz#ComputeShapeSignature.__decl_suffix  s#    $$%Qt';';&<A>>r<   c                 :    | j                    d| j                   dS r+  )r(  r'  r,  s    r:   __call_suffixz#ComputeShapeSignature.__call_suffix  s#    $$%Qt'7'7&8::r<   c                 (    d| j                          S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixr,  s    r:   
shape_declz ComputeShapeSignature.shape_decl  s    I$J\J\J^I_``r<   c                 (    d| j                          S )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixr,  s    r:   r  z ComputeShapeSignature.shape_call  s    ,T-?-?-A,BCCr<   N)r   r   r   __doc__r   r#   r   r)  r1  r4  propertyr2  r  ry   r<   r:   r   r   ~  su    )C )N )t )?s ?;s ; aC a a DC D Dr<   r   c                   B    e Zd ZU eed<   eed<   ededee   fd       Z	y)GenLazyShapeInferenceDefinitionrh   r   rl   r&   c                 X   t        || j                        }| j                  j                  |      }|J d|j                  v }|j                  xs |j
                  d u}|s|rg S t        |j                  ||j                               }dj                  |j                   dg      gS )Nr   rn   
r   )r   rh   rp   r   r   r   r   r  rq   rA   r2  )rs   rl   rD   rt   r  r  r  s          r:   ru   z(GenLazyShapeInferenceDefinition.__call__  s    q$"4"45%%003### &/I(=(=T(IOI-8+C+C+EI II)"6"6!7q9:;<<r<   N)
r   r   r   r   r   r   r   r#   r   ru   ry   r<   r:   r8  r8    s2     =. =T#Y = !=r<   r8  
non_nativegen_lazy_irc                 4   g }| D ]  }t        ddd      }|j                  dg       D ]  }t        ||d        t        t	        j
                  |d         |d      }|j                  d      |_        |j                  |j                  |      d	           |S )
z,Generate the non-native lazy IR node classesr   r   r   r   TrH   rn   r   r   )	r   getsetattrr   r!   parser   r^   rr   )r;  r<  nodesopr   pr=   s          r:   !generate_non_native_lazy_ir_nodesrD    s     E 	1%lM?S
b) 	)AJ4(	) n222f:>
SWXx([__V,Q/0	1 Lr<   );r   abcr   dataclassesr   typingr   r   r   r   r	   r
   torchgen.api.dispatcherapir%  torchgen.api.lazyr   r   r   r   r   r   torchgen.api.translater   torchgen.api.typesr   r   r   r   r   r   r   r   torchgen.contextr   torchgen.dest.lazy_ts_loweringr   torchgen.modelr   r   r   r   r    r!   r"   r#   r$   r   r;   rC   rS   rM   rd   rg   r   r   r   r8  rD  ry   r<   r:   <module>rP     s     ! : : , ,  -	 	 	 9 ;
 
 
8!\ 8!c 8!v'\ 'c '	"O3	4  		0
  
  
  +!4 +sDM?Q9R +  $i
 i
 i
X $5) 5 5p $n
 n
 n
bD D< $= = =,T#s(^$3<	#Yr<   