
    Χg>q                    .   d dl mZ d dlZd dlmZ d dlmZ d dl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-dZ,d.dZ-d/dZ.d.dZ/d0dZ0 ed           G d de                      Z1 ed           G d  d!e1                      Z2 ed           G d" d#                      Z3 G d$ d%          Z4 ed           G d& d'                      Z5d1d,Z6dS )2    )annotationsN)ABC)	dataclass)Any)	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argr	   returnstrc                j   t          | j                  rt          | j        t                    rL| 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                    rL| j        j        t          t          j                  k    r%| j        rd| j         dS d| j         d| j         dS t          | j        t$                    rDt          | j        j        t                    r%d| j        j        j         d| j         d| j         dS t          | j        t                    ret          | j        j        t$                    rFt          | 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& ? std::make_optional(GetSymIntValue(*z)) : ::std::nulloptz ? std::make_optional(lazy_z ->GetIrValue()) : ::std::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    Q/var/www/html/ai-engine/env/lib/python3.11/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_stringr8   +   s    3=!! 0!cmY// 	$ 5)sx)))#'7774sx4444& 5444443383333}55 	$ * (gg#(gggg& *)sx)))! ! !+.8! ! ! !`PSP]```   cmX.. 	!3=3EMJ
 J
 4
 4
 z U<<<<<TsxTT38TTTT{33 	!
M	9
 9
 	! c#-"4"9bbSXbbQTQYbbbbs}m44	!3=-{;;	! 3=-2I>>	!
 `CM4F4K4P__TWT\____h=     schemar   c                h    d |                                  D             }d                    |          S )zg
    Produce a formatted string with the arguments as passed into the constructor of a node class.
    c                ,    g | ]}t          |          S  )r8   .0r!   s     r7   
<listcomp>z$node_ctor_inputs.<locals>.<listcomp>j   s.       -0#C((  r9   , )filtered_argsjoin)r:   node_ctor_valuess     r7   node_ctor_inputsrE   f   sB     4:4H4H4J4J   99%&&&r9   sig%DispatcherSignature | NativeSignatureoverload_namec                ^   t          j        | j                  }t          |                                |                                          }d                    d |D                       }t          |          rd| j         d| d}nd| j         d}dt          |            d| d	| d
S )zK
    Generate code that falls back to eager conditioned on a predicate
    z,
                c                    g | ]	}|j         
S r=   exprr?   as     r7   r@   z%gen_fallback_code.<locals>.<listcomp>z   s    /F/F/F1/F/F/Fr9   z	ATEN_OP2(rA   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   	argumentsrC   len	aten_nameaten_symbol)r:   rF   rH   dispatcher_sigexprsfallback_argsaten_op_strs          r7   gen_fallback_coderY   p   s     )4V[AANcmmoo~'?'?'A'ABBE)../F/F/F/F/FGGM
= 5F&"2FFmFFF4!1444"-f"5"5 MX     r9   c                    dh}| j         |v rd| j          dS | j                             d          s
d| j          S | j         S )Nsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rS   
startswith)r:   missing_interned_stringss     r7   rT   rT      se      333IV5EIIII&&v..  .F,...r9   r   tuple[str, list[Binding]]c                   g }g }|                                  D ]}t          |j        t                    rr|j        j                                        rT|j         d}|                    d| d|j         d           |                    |                    |                     |                    |           d	                    |          }||fS )N_metazauto z = to_meta();	
        )
rQ   r-   argumentr   r0   is_tensor_liker/   append	with_namerC   )rF   contextunwrapped_tensor_argsr!   unwrapped_nameunwrap_tensor_args_strs         r7   convert_to_meta_tensorsrk      s    G')}}    clH-- 	 #,2C2R2R2T2T 	  #///N!((???38???   NN3==889999NN3)../DEE!7**r9   T)frozenc                  x    e Zd ZU ded<   ded<   ded<   ded<   edd            ZddZddZddZddZ	ddZ
dS )	GenLazyIRr   backend_indexr#   backend_name	node_basebooluse_lazy_shapef%NativeFunctionsGroup | NativeFunctionr"   	list[str]c                6   t          |t                    r|j        j        n|j        }| j                            t          |t                    r|j        n|          }t          ||d uo|                                          }|                     |          S )Nr6   )	r-   r    
functionalrP   ro   
get_kernelr   supports_symintgen)selfrt   rP   metadatar:   s        r7   __call__zGenLazyIR.__call__   s    $.q2F$G$GSq|  QV%00&q*>??FALLQ
 
 -L(2J2J2L2L
 
 
 xxr9   r:   r   c                    dS N r=   )r}   r:   s     r7   lowering_functionzGenLazyIR.lowering_function       rr9   node_ctor_argsc                    dS r   r=   r}   r:   r   s      r7   create_functionzGenLazyIR.create_function   r   r9   c                    d| dS )Nbool CanBeReused(z!) const {
    return false;
    }r=   r   s      r7   can_be_reused_functionz GenLazyIR.can_be_reused_function   s    
^ 
 
 
 	
r9   c                   |                     dd          }g }|D ]}t          |j        t          t          f          r|                    |j                    ?t          |j        t                    r|                    |j         d           wt          d|j         d          d	                    |          }|                     dd          }|j
        j        rd}n|j
        j        rMd	 |D             }|                    d
 |D                        d|j         dd	                    |           d}nu|j
        j        rgd t          t!          |                    D             }|                    d |D                        d|j         dd	                    |           d}nd}d	                    d |D                       }	| j         d|j         d| d| dt!          |j                   d|	 dS )NTFvaluesscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryrA   zstd::move(shapes),c                    g | ]	}|j         
S r=   r/   rM   s     r7   r@   z1GenLazyIR.node_base_ctor_call.<locals>.<listcomp>   s    555Q!&555r9   c              3  $   K   | ]}|j         V  d S Nr   rM   s     r7   	<genexpr>z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   $      ::af::::::r9   compute_shape_(z),c                    g | ]}d | d	S )zoperand(r(   r=   r?   is     r7   r@   z1GenLazyIR.node_base_ctor_call.<locals>.<listcomp>   s     JJJa/Q///JJJr9   c              3  $   K   | ]}|j         V  d S r   r   rM   s     r7   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   r   r9   z[&](){ return compute_shape_z)[0]; },r   c              3  &   K   | ]}|j          V  d S r   r   rM   s     r7   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   s&      !C!C!QV+!C!C!C!C!C!Cr9   z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))rB   r-   r,   r   r   re   r/   r   r2   rC   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerR   rq   	node_namereturns)
r}   r:   
value_argsbase_ctor_value_args_listr!   base_ctor_value_argsscalar_argsshape_ctor_arg
shape_argsscalar_hashess
             r7   node_base_ctor_callzGenLazyIR.node_base_ctor_call   sz   ))u)EE
 %'! 	 	C#-)[)ABB )00CH????CM=99 )00CH1S1S1STTTT$TTTT    $yy)BCC**%*FF , 	 1NN+ 		 55*555J::k::::::UfkUUDIIj<Q<QUUUNN) 	 JJ5Z3I3IJJJJ::k::::::kV[kk499U_K`K`kkkNNN		!C!C{!C!C!CCCN 6 66 6+6 6 6 6 "%V^!4!4	6 6
 #06 6 6 	6r9   c                   |j         pt          |          }|                                }|                    dd          }d |D             }d                    |          }| j        r!|j        j        r|                    d           d                    |          }d                    d |D                       }t          |          rd| }d	                    d
 |D                       }	d |                    dd          D             }
d	                    d |
D                       }d                    d |
D                       }g }|D ]}t          |j
        t                    rE|j         d}|j        rd}|                    d|j         d|j         d| d|j         d	           a|                    d|j         d|j         d           d                    |          }d|j         d| j         d| d|j         d| d|                     |           | d| d| j         d | d!|                     ||           d"|                     ||           d"|                     |           d"|	 d	| d#gS )$NFTr   c                V    g | ]&}d |j                                          d|j         'S )zconst z& r,   cpp_typer/   r   s     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>   s9    SSSQ@ak2244@@@@SSSr9   rA   z(std::vector<torch::lazy::Shape>&& shapesz
,
        c                    g | ]K}|j                                         d k    r|j         d|j         d|j         dn|j         d|j         dLS )!::std::optional<c10::string_view>r   z1.has_value() ? ::std::make_optional(std::string(*z)) : ::std::nullopt)r(   r   rM   s     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>   s       
  ;''))-PPP 6qqAFqqUVU[qqqq*****	  r9   z
  c                    g | ]v}|j                                         d k    rd|j         dnK|j                                         dk    rd|j         dn#|j                                          d|j         dwS )zc10::string_viewzstd::string ;r   z::std::optional<std::string>  r   rM   s     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>  s        	 ;''))-??? )qv(((( ;''))-PPP ?QV>>>>,,..:::::  r9   c                P    g | ]#}t          |j        t                    |j        $S r=   )r-   r,   r   r/   r>   s     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>  s<     
 
 
#-77
H
 
 
r9   c                    g | ]}d | d	S )z	bool has_z: 1;r=   r?   values     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>  s$    BBB$$$$BBBr9   z
    c                     g | ]}d | d| dS )has_z = !!r   r=   r   s     r7   r@   z!GenLazyIR.gen.<locals>.<listcomp>  s,    FFFU(E(((((FFFr9   z.value()z"torch.Generator()"zif (z.has_value()) {
      ss << ", z=" << z;
    } else {
      ss << ", z=null";
    }z	ss << ", r   zclass z
 : public zX {
 public:
  static torch::lazy::OpKind ClassOpKind() {
    return torch::lazy::OpKind(z
);
  }

  r   z
)
      : z	
  {
    zT
  }

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

  z

  z

};

)opkindrT   rB   rC   rs   r   r   re   rR   r-   r,   r   r/   is_generatorr   rq   r   r   r   r   )r}   r:   r   all_argsr   	ctor_argsreuse_ctor_argsr   scalar_initializersscalar_declsoptional_valueshas_optional_declshas_optional_defsmembers_to_stringr!   r   members_to_string_strs                    r7   r|   zGenLazyIR.gen   s   5+f"5"5 ''))**%*FFSS(SSS	))I.. 	I6#4#D 	IGHHH9--+00 
 %  
 
 "## 	F"E0C"E"E{{  %  	
 	

 
++4+GG
 
 

 $[[BB/BBB
 
 %MMFFoFFF
 
  	R 	RC#-77 R8---# 21E!((
SX 
 

 
 %
 
 
 
 
    "(()PSX)P)PSX)P)P)PQQQQ (.? @ @ #'>  !'	  
  %  
	!	!&	)	) ,?    >   ! ( 00) , v77- 0 &!!1 4 5 6 7  !
 !	
r9   N)rt   ru   r"   rv   r:   r   r"   r#   r:   r   r   r#   r"   r#   )r:   r   r"   rv   )__name__
__module____qualname____annotations__r   r   r   r   r   r   r|   r=   r9   r7   rn   rn      s         NNN       !        
 
 
 

(6 (6 (6 (6T`
 `
 `
 `
 `
 `
r9   rn   c                  &    e Zd Zd
dZddZddZd	S )GenTSLazyIRr:   r   r"   r#   c                n    d}|j         j        r| dS |j         j        r| dt          |           dS dS )Nz
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider   z {
    z
  }
            r   )r   LowerDeclOnlyLowerr   )r}   r:   	signatures      r7   r   zGenTSLazyIR.lowering_functionV  sf    ?	
 * 	???"$ 	!  f   
 2r9   r   c                f    d| d}|j         j        r| dS |j         j        sdS | d|j         dS )Nzstatic NodePtr Create(r(   r   r   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )r}   r:   r   r   s       r7   r   zGenTSLazyIR.create_functionf  sf    >^>>>	- 	???""+ 	2  ",   	r9   c                   d| d}|j         j        r| dS |j         j        sdS g }t          j        |j        |j                  D ]X}t          |j        t                    r|
                    d|j         d           ;|
                    d|j                    Yt          j        |j        |j                  D ]}t          |j        t                    rG|
                    d|j         d	|j         d
|j         d|j         d|j         d|j         d           c|
                    d|j         d|j                    d                    |          }| d| dS )Nr   z) constr   r   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_valuesr-   r,   r   re   r/   positional_scalarskeyword_scalarsrC   )r}   r:   r   r   value_comparisonr!   value_comparison_strs          r7   r   z"GenTSLazyIR.can_be_reused_functionp  s   ????	0 	???"". 	2?6#;V=RSS 	G 	GC#-77 G ''OOOO    !''(E38(E(EFFFF?6#<f>TUU 	K 	KC#-77 K '' B  B  BSX  B  B38  B  Bsx  B  Behem  B  Buxu}  B  B  B    !''(I(I(Isx(I(IJJJJ.334DEE  !   	r9   Nr   r   )r   r   r   r   r   r   r=   r9   r7   r   r   T  sP                    r9   r   c                      e Zd ZU ded<   ded<   ded<   ded<   ded<   ded	<   ded
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   d)dZd*dZd)dZd)dZd)d Zd)d!Z	d+d,d%Z
d)d&Zed-d(            Zd"S ).GenLazyNativeFuncDefinitionr#   class_method_namer   ro   tensor_classrr   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_fnrP   r   r:   r   r"   c                   |                     dd          }g }|D ]}|j        rpt          |j        t                    r/|                    d|j         d|j         d|j         d           S|                    d|j         d|j         d	           z|j        rt          |j        t                    r|j        j	        t          u r7|                    d
|j         d| j         d| j         d|j         d	           |                    | j         d|j         d| j         d| j         d|j         d	
           %t          |j        t                    r||j        j        t          t!                                k    sJ |j        j                    |                    | j         d|j         d| j         d| j         d|j         d
           t%          d|j         d          d                    |          S )NTFr   z
auto node_z = z ?
                std::make_optional(torch::lazy::LazyGraphExecutor::Get()->
                    GetIrValueForScalarFromCodegen(*z3, *common_device)):
                ::std::nullopt;zf = torch::lazy::LazyGraphExecutor::Get()->
                            GetIrValueForScalarFromCodegen(z, *common_device);z
auto lazy_z_tensorlist = ::r   ra   z lazy_z.value_or(at::Tensor()));r)   r(   rb   )rB   r.   r-   r,   r   re   r/   r1   r   r0   r   r   r   r   r   r4   r   r   r2   rC   )r}   rP   r:   r   lazy_tensor_declsr!   s         r7   r   z-GenLazyNativeFuncDefinition.lazy_tensor_decls  s
   ))u)EE
') &	 &	C$ %cm];; %,,#sx # #CH # #58X# # #    &,,[sx [ [<?H[ [ [    & CM955 =%)999%,,XSX X X1X X595HX XKN8X X X   
 &,,/ s ssx s s1s s595Ss sVYV^s s s    CM=99 })Yy{{-C-CCCCS]EWCCC "((+ k k38 k k-k k151Dk kGJxk k k   
 %dTWTaddd   ""#4555r9   r~   r   rF   rG   c                V    | j         r!t          |||j        j        j                  S dS )N)rH   r   )r   rY   rP   r/   rH   )r}   rP   r:   r~   rF   s        r7   force_eager_fallbackz0GenLazyNativeFuncDefinition.force_eager_fallback  s;     ( 	$49>+G    rr9   c                    | j          dS )Nr   )r   )r}   rP   r:   s      r7   metricsz#GenLazyNativeFuncDefinition.metrics  s    &))))r9   c                   |                     dd          }|                     dd          }d |D             }t          t          t                              fd|D             }t	          |          dk    st	          |          dk    s
J d            | j         dd	                    ||z              d
}d| dS )NTFr   c                ,    g | ]}|j         	|j         S r=   r.   r/   rM   s     r7   r@   z:GenLazyNativeFuncDefinition.get_device.<locals>.<listcomp>  $    XXXQADWX[XXXr9   c                4    g | ]}|j         k    |j        S r=   )r,   r/   )r?   rN   optional_devices     r7   r@   z:GenLazyNativeFuncDefinition.get_device.<locals>.<listcomp>  s.     
 
 
1;/+I+IAF+I+I+Ir9   r   z*Expected at least one Value or Device typer   rA   r(   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )rB   r   r   r   rR   r   rC   )	r}   rP   r:   r   r   value_types_namesoptional_devicesget_device_strr   s	           @r7   
get_devicez&GenLazyNativeFuncDefinition.get_device  s   ))u)EE
**%*FFXX*XXX'	'(:(:;;
 
 
 
'
 
 
 !""Q&&#.>*?*?!*C*C*C7 +D*C*C !VVDII.?BR.R$S$SVVV 	    	r9   c           
        | j                             |          }|J |                                }t          |j                  }d|j        v }|j        p|j        d u}|s|r	d}|dk    r:d#dd	                    fd
t          |          D                       }	d|	z   dz   }t          j        |j                  }
t          |
          \  }}d t          ||
                                d          D             }|r|j        sJ d}nd}|j        }|j                                        r|                                r|dz  }d| d| d| dd                    |           d| 
}n4t)          |j        ||                                          }d|j         d}|d| dz  }dt/          |j                  z   }|dd                    d  |D                        d!| d"z  }|S )$N	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};   r   intr"   r#   c                    d|  d|  dS )Nztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())r=   )r   s    r7   
this_shapez?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape  s    ~!~~ab~~~~r9   ,c                &    g | ]} |          S r=   r=   )r?   r   r
  s     r7   r@   z?GenLazyNativeFuncDefinition.shape_inference.<locals>.<listcomp>  s!    &T&T&Tzz!}}&T&T&Tr9   z'std::vector<torch::lazy::Shape> shapes{z};c                    g | ]	}|j         
S r=   rK   )r?   es     r7   r@   z?GenLazyNativeFuncDefinition.shape_inference.<locals>.<listcomp>  s*          r9   F)method&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r   r   rA   z);
        rx   z
            auto shapes = r   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == ra   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c              3  >   K   | ]}t          |j                  V  d S r   )r#   r/   rM   s     r7   r   z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>2  s+      FeFeWXs16{{FeFeFeFeFeFer9   z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )r   r  r"   r#   )ro   rz   rB   rR   r   tags
structuredstructured_delegaterC   r   r   rO   rP   rk   r   rQ   5has_composite_explicit_autograd_non_functional_kernelrS   
has_symintr{   ComputeShapeSignaturekernel
shape_callr#   )r}   rP   r:   r~   r   returns_lengthis_view_copy_opis_structuredmeta_out
shapes_strrU   meta_conversion_strmeta_call_ctxmeta_call_argsdispatch_nsrS   	shape_str	shape_sigfunc_schema_strr
  s                      @r7   shape_inferencez+GenLazyNativeFuncDefinition.shape_inference  s   %0066###''))V^,, &2O4+C4+O *	5O *	5oH!!    !XX&T&T&T&TeN>S>S&T&T&TUU
DzQTXX 1<TYGGN1H1X1X. "!>#;#;#=#=e    N  %QQQQF$(Iy##%% '(*B*B*D*D 'Y&		 ( ,5 8<		.8Q8Q  
 II
 .h.F.F.H.H  I5$/5 5 5I 	 I4BI I I 	I	 #S^^3 =AYYFeFe\dFeFeFe=e=e  ,;   		 r9   c                    t          |          }d|j         d| d|                     ||           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);
        }
        )rE   r   r(  )r}   rP   r:   node_ctor_input_strs       r7   build_ir_nodez)GenLazyNativeFuncDefinition.build_ir_node9  sz    .v66vGW  [n  !!$//  +1*:  ?R   	r9   Nfirst_tensor_name
str | Nonec                b    | j         r|
J d            | d| j         S | j         d| j         S )Nz+Requires first tensor to create lazy tensor.r   )r   r   r   )r}   r,  s     r7   create_lazy_tensorz.GenLazyNativeFuncDefinition.create_lazy_tensorC  sW    ( 	? "--< .--'>>$*<>>>(@@D,>@@@r9   c                J   t          |j                  }|                    dd          }d |D             }t          |          dk    r|d         nd }d| j         d|                     |           d}|d	k    r[t          |          dk    s
J d
            d| j         d| d|                     |           dt                       d| j         d| d}|j        j        j	        s|j
                                        r|d	k    sJ d| d            d| d| d}|dz  }|S )NTFr   c                ,    g | ]}|j         	|j         S r=   r   rM   s     r7   r@   zBGenLazyNativeFuncDefinition.return_aten_tensor.<locals>.<listcomp>P  r   r9   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;)rR   r   rB   r   r0  r   r   r   r/   inplacerP   	is_out_fn)r}   rP   r:   r  r   r  r,  
bridge_strs           r7   return_aten_tensorz.GenLazyNativeFuncDefinition.return_aten_tensorM  s   V^,,))u)EE
XX*XXX478I4J4JQ4N4N-a00TXc(H c c(():;;c c c
 A%&&***D +**]$*> ] ]+] ]$($;$;<M$N$N] ]QZQ\Q\] ] 7	] ] ;I	] ] ]J ;# 	/ty':':'<'< 	/!Q&&&Q?MQ Q Q '&&/#4 / /)/ / /J 	  	
r9   rv   c                $   t          || j                  }| j                            |          }|J t          |j        |                                          }d|                    | j         d|j                    d| 	                    ||||           d| 
                    ||           d|                     ||           d|                     ||           d|                     ||           d|                     ||           dgS )Nrx   z    r   r   z {
        rb   z
    }

    )r   ro   rz   r   rP   r{   declr   r  r   r   r  r   r+  r7  )r}   rP   rF   r~   r:   s        r7   r   z$GenLazyNativeFuncDefinition.__call__k  sP   tT%788%0066###di0H0H0J0JKKK	XXd,AAAAXBB	 			"	"43	?	?	 	 
dF	#	#	 	 
v	&	&		 	
 
		f	-	-	 	 
		D&	)	)	 	 
	 	 v	.	.	 	 	
 	
r9   )rP   r   r:   r   r"   r#   )
rP   r   r:   r   r~   r   rF   rG   r"   r#   r   )r,  r-  r"   r#   )rP   r   r"   rv   )r   r   r   r   r   r   r   r  r(  r+  r0  r7  r   r   r=   r9   r7   r   r     s        """"""""""""$$$$$$$$+6 +6 +6 +6Z   * * * *   $I I I IV   A A A A A   < !
 
 
 ! 
 
 
r9   r   c                  Z    e Zd ZdZdd
ZddZddZedd            Zedd            Z	dS )r  zm
    Here we use the base name as the suffix of the signature to avoid generating for in-place variants.
    kernel_namer#   rt   r   r6   rr   r"   Nonec               >   t          |j        |          | _        d                    d t	          j        |j        |          D                       | _        d                    d | j                            d          D                       | _        || _	        d S )Nrx   rA   c                6    g | ]}|                                 S r=   )r9  rM   s     r7   r@   z2ComputeShapeSignature.__init__.<locals>.<listcomp>  s     KKK!QVVXXKKKr9   c                    g | ]
}|j          S r=   r   r>   s     r7   r@   z2ComputeShapeSignature.__init__.<locals>.<listcomp>  s    RRRs]RRRr9   T)	generator)
r   rP   _ComputeShapeSignature__schemarC   
dispatcherrQ   %_ComputeShapeSignature__dispatch_argsrB   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)r}   r;  rt   r6   s       r7   __init__zComputeShapeSignature.__init__  s    $QVF;;;#yyKKz3AF6JJJKKK 
  
  99RRdm&A&AD&A&Q&QRRR
 
 )r9   c                &    | j          d| j         dS Nr   r(   )rE  rC  r}   s    r7   __decl_suffixz#ComputeShapeSignature.__decl_suffix  s    $>>t';>>>>r9   c                &    | j          d| j         dS rH  )rE  rD  rI  s    r7   __call_suffixz#ComputeShapeSignature.__call_suffix  s    $::t'7::::r9   c                0    d|                                   S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixrI  s    r7   
shape_declz ComputeShapeSignature.shape_decl  s    `$J\J\J^J^```r9   c                0    d|                                   S )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixrI  s    r7   r  z ComputeShapeSignature.shape_call  s    CT-?-?-A-ACCCr9   N)r;  r#   rt   r   r6   rr   r"   r<  )r"   r#   )
r   r   r   __doc__rF  rN  rQ  propertyrO  r  r=   r9   r7   r  r    s         ) ) ) )? ? ? ?; ; ; ; a a a Xa D D D XD D Dr9   r  c                  <    e Zd ZU ded<   ded<   edd	            Zd
S )GenLazyShapeInferenceDefinitionr   ro   r#   r   rt   r   r"   rv   c                   | j                             |          }|J d|j        v }|j        p|j        d u}|s|rg S t          |j        ||                                          }d                    |j	         dg          gS )Nr  rx   
r   )
ro   rz   r  r  r  r  r  r{   rC   rO  )r}   rt   r~   r  r  r&  s         r7   r   z(GenLazyShapeInferenceDefinition.__call__  s    %0033### &/I(=T(I 	=O 	=I-8+C+C+E+E  I II)"6999:;;<<r9   N)rt   r   r"   rv   )r   r   r   r   r   r   r=   r9   r7   rU  rU    sM          = = = ! = = =r9   rU  
non_nativelist[dict[str, Any]]gen_lazy_irrv   c                n   g }| D ]}t          ddd          }|                    dg           D ]}t          ||d           t          t	          j        |d                   |d          }|                    d          |_        |                    |                    |          d	                    |S )
z,Generate the non-native lazy IR node classesr   r   r   r   TrP   rx   r   r   )	r
   getsetattrr   r   parser   re   r|   )rX  rZ  nodesopr   pr:   s          r7   !generate_non_native_lazy_ir_nodesrb    s     E 	1 	1%lM?SS
b)) 	) 	)AJ4(((( n22f:>>
SWXXXx(([__V,,Q/0000Lr9   )r!   r	   r"   r#   r   )r:   r   rF   rG   rH   r#   r"   r#   )rF   r   r"   r^   )rX  rY  rZ  rn   r"   rv   )7
__future__r   r   abcr   dataclassesr   typingr   torchgen.api.dispatcherapirB  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    r8   rE   rY   rT   rk   rn   r   r   r  rU  rb  r=   r9   r7   <module>ro     s   " " " " " "           ! ! ! ! ! !       , , , , , , , , ,                - , , , , ,	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 9 8 8 8 8 8 ; ; ; ; ; ;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8! 8! 8! 8!v' ' ' '   0
  
  
  
  + + + +  $h
 h
 h
 h
 h
 h
 h
 h
V $5 5 5 5 5) 5 5 5p $n
 n
 n
 n
 n
 n
 n
 n
bD D D D D D D D< $= = = = = = = =*     r9   