o
    hYr                     @   s  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  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dZ0dede/fddZ1dedeeef de/de/fddZ2dede/fddZ3dede
e/ee f fddZ4eddG dd deZ5eddG dd de5Z6eddG d d! d!Z7G d"d# d#Z8eddG d$d% d%Z9d&eee/ef  d'e5dee/ fd(d)Z:dS )*    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                 C   s  t | jrbt| jtr2| 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	rY| jrE| j d| j dS | jrNd| j S d| j d	| j d
S t
d| j dt| jtr| jjttjkr| jr{d| j dS d| j d| j dS t| jtrt| jjtrd| jjj d| j d| j dS t| jt	rt| jjtrt| jjjtrd| 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$    r8   K/var/www/html/ai/venv/lib/python3.10/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_string)   sN   

"
r:   schemac                 C   s   dd |   D }d|S )zg
    Produce a formatted string with the arguments as passed into the constructor of a node class.
    c                 S   s   g | ]}t |qS r8   )r:   .0r$   r8   r8   r9   
<listcomp>h   s    z$node_ctor_inputs.<locals>.<listcomp>, )filtered_argsjoin)r;   node_ctor_valuesr8   r8   r9   node_ctor_inputsd   s   
rC   sigoverload_namec              	   C   s   t | j}t| | }ddd |D }t|r(d| j d| d}nd| j d}d}| jrAd	| jj	 d
| jj	 d}dt
|  d| d| d| d	S )zK
    Generate code that falls back to eager conditioned on a predicate
    z,
                c                 S      g | ]}|j qS r8   exprr=   ar8   r8   r9   r>   x       z%gen_fallback_code.<locals>.<listcomp>z	ATEN_OP2(r?   r)   zATEN_OP( z || (z.has_value() && z->defined())z"
        if (force_eager_fallback(zP) {
            return at::native::call_fallback_fn_symint<&ltc_eager_fallback, z>::call(
                z
            );
        }
)r   from_schemafuncr   	argumentsrA   len	aten_namegenerator_argr0   aten_symbol)r;   rD   rE   dispatcher_sigexprsfallback_argsaten_op_stror_has_generatorr8   r8   r9   gen_fallback_coden   s$   rY   c                 C   s<   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::)rQ   
startswith)r;   missing_interned_stringsr8   r8   r9   rS      s   
rS   c                 C   s   g }g }|   D ]/}t|jtr2|jj r2|j d}|d| d|j d ||| q|| qd	|}||fS )N_metazauto z = to_meta();	
        )
rO   r.   argumentr   r1   is_tensor_liker0   append	with_namerA   )rD   contextunwrapped_tensor_argsr$   unwrapped_nameunwrap_tensor_args_strr8   r8   r9   convert_to_meta_tensors   s   
rh   T)frozenc                   @   s   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dZd	edefd
dZd	ededefddZd	ededefddZd	edefddZd	edee fddZdS )	GenLazyIRbackend_indexbackend_name	node_baseuse_lazy_shapefr%   c                 C   sV   t |tr	|jjn|j}| jt |tr|jn|}t||d uo#| d}| |S )Nr7   )	r.   r#   
functionalrN   rk   
get_kernelr   supports_symintgen)selfro   rN   metadatar;   r8   r8   r9   __call__   s   
zGenLazyIR.__call__r;   c                 C      dS NrL   r8   )ru   r;   r8   r8   r9   lowering_function      zGenLazyIR.lowering_functionnode_ctor_argsc                 C   rx   ry   r8   ru   r;   r|   r8   r8   r9   create_function   r{   zGenLazyIR.create_functionc                 C   s   d| dS )Nbool CanBeReused(z!) const {
    return false;
    }r8   r}   r8   r8   r9   can_be_reused_function      z GenLazyIR.can_be_reused_functionc           
      C   sp  |j ddd}g }|D ]*}t|jttfr||j  qt|jtr-||j d qtd|j dd	|}|j ddd}|j
jrId}nL|j
jrld	d
 |D }|dd |D  d|j dd	| d}n)|j
jrdd
 tt|D }|dd |D  d|j dd	| d}nd}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 necessaryr?   zstd::move(shapes),c                 S   rF   r8   r0   rI   r8   r8   r9   r>      rK   z1GenLazyIR.node_base_ctor_call.<locals>.<listcomp>c                 s       | ]}|j V  qd S Nr   rI   r8   r8   r9   	<genexpr>       z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>compute_shape_(z),c                 S      g | ]}d | dqS )zoperand(r)   r8   r=   ir8   r8   r9   r>          c                 s   r   r   r   rI   r8   r8   r9   r      r   z[&](){ return compute_shape_z)[0]; },rL   c                 s   s    | ]}|j  V  qd S r   r   rI   r8   r8   r9   r      s    z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))r@   r.   r-   r   r   rb   r0   r   r3   rA   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerP   rm   	node_namereturns)
ru   r;   
value_argsbase_ctor_value_args_listr$   base_ctor_value_argsscalar_argsshape_ctor_arg
shape_argsscalar_hashesr8   r8   r9   node_base_ctor_call   sF   
zGenLazyIR.node_base_ctor_callc                 C   s  |j pt|}| }|jddd}|jddd}dd |D }d|}| jr1|jjr1|d d|}dd	d |D }	t|	rId|	 }	d
dd |D }
dd |jdddD }d
dd |D }ddd |D }g }|D ]-}t	|j
tr|d|j d|j d|j d|j d	 qw|d|j d|j d qwd|}d|j d| j d| d|j d| d| | |	 d| d| j d| d | || d!| || d!| | d!|
 d
| d"gS )#NTFr   c                 S   s$   g | ]}d |j   d|j qS )zconst z& r-   cpp_typer0   r   r8   r8   r9   r>      s   $ z!GenLazyIR.gen.<locals>.<listcomp>r?   z(std::vector<torch::lazy::Shape>&& shapesz
,
        c                 S   sJ   g | ]!}|j  d kr|j d|j d|j dn	|j d|j dqS )c10::optional<c10::string_view>r   z/.has_value() ? c10::make_optional(std::string(*z)) : c10::nullopt)r)   r   rI   r8   r8   r9   r>     s    z
  c                 S   s\   g | ]*}|j  d krd|j dn|j  dkr d|j dn|j   d|j dqS )zc10::string_viewzstd::string ;r   zc10::optional<std::string>  r   rI   r8   r8   r9   r>     s    c                 S   s   g | ]}t |jtr|jqS r8   )r.   r-   r   r0   r<   r8   r8   r9   r>     s    
c                 S   r   )z	bool has_z: 1;r8   r=   valuer8   r8   r9   r>     r   z
    c                 S   s   g | ]}d | d| dqS )has_z = !!r   r8   r   r8   r8   r9   r>      s    zif (z.has_value()) {
      ss << ", z=" << z&.value();
    } 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

};

)opkindrS   r@   rA   rn   r   r   rb   rP   r.   r-   r   r0   r   rm   r   r~   r   rz   )ru   r;   r   all_argsr   r   	ctor_argsreuse_ctor_argsr|   scalar_initializersscalar_declsoptional_valueshas_optional_declshas_optional_defsmembers_to_stringr$   members_to_string_strr8   r8   r9   rt      s   


	






zGenLazyIR.genN)__name__
__module____qualname__r   __annotations__strboolr   r	   r#   r"   r   rw   r   rz   r~   r   r   rt   r8   r8   r8   r9   rj      s   
  *rj   c                   @   sJ   e Zd ZdedefddZdededefddZdededefdd	Zd
S )GenTSLazyIRr;   r%   c                 C   s6   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
  }
            rL   )r   LowerDeclOnlyLowerr   )ru   r;   	signaturer8   r8   r9   rz   V  s   
zGenTSLazyIR.lowering_functionr|   c                 C   s<   d| d}|j jr| dS |j jsdS | d|j dS )Nzstatic NodePtr Create(r)   r   rL   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )ru   r;   r|   r   r8   r8   r9   r~   f  s   
zGenTSLazyIR.create_functionc                 C   s  d| d}|j jr| dS |j jsdS g }t|j|jD ]}t|jt	r2|
d|j d q|
d|j  qt|j|jD ]4}t|jt	rk|
d|j d	|j d
|j d|j d|j d|j d qD|
d|j d|j  qDd|}| d| dS )Nr   z) constr   rL   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   rb   r0   positional_scalarskeyword_scalarsrA   )ru   r;   r|   r   value_comparisonr$   value_comparison_strr8   r8   r9   r   p  s,   
4
z"GenTSLazyIR.can_be_reused_functionN)r   r   r   r   r   rz   r~   r   r8   r8   r8   r9   r   T  s    
r   c                
   @   sb  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dZ	dedede
deeef def
ddZdededefddZdededefddZdededefddZdededefdd Zd)d"ee defd#d$Zdededefd%d&Zededee fd'd(Zd!S )*GenLazyNativeFuncDefinitionclass_method_namerk   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_fnrN   r;   r%   c                 C   sl  |j ddd}g }|D ]}|jr8t|jtr)|d|j d|j d|j d q|d|j d|j d	 q|jr<qt|jtry|jj	t
u r_|d
|j d| j d| j d|j d	 q|| j d|j d| j d| j d|j d	
 qt|jtr|jjtt ksJ |jj|| j d|j d| j d| j d|j d
 qtd|j dd|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   r^   z lazy_z.value_or(at::Tensor()));r*   r)   r_   )r@   r/   r.   r-   r   rb   r0   r2   r   r1   r   r   r   r   r   r5   r
   r   r3   rA   )ru   rN   r;   r   lazy_tensor_declsr$   r8   r8   r9   r     sh   


z-GenLazyNativeFuncDefinition.lazy_tensor_declsrv   rD   c                 C   s   | j rt|||jjjdS dS )N)rE   rL   )r   rY   rN   r0   rE   )ru   rN   r;   rv   rD   r8   r8   r9   force_eager_fallback  s
   z0GenLazyNativeFuncDefinition.force_eager_fallbackc                 C   s   | j  dS )Nr   )r   )ru   rN   r;   r8   r8   r9   metrics  r   z#GenLazyNativeFuncDefinition.metricsc                    s   |j ddd}|j ddd}dd |D }ttt  fdd|D }t|dks4t|dks4J d| j d	d
||  d}d| dS )NTFr   c                 S      g | ]	}|j s|j qS r8   r/   r0   rI   r8   r8   r9   r>         z:GenLazyNativeFuncDefinition.get_device.<locals>.<listcomp>c                    s   g | ]
}|j  kr|jqS r8   )r-   r0   rI   optional_devicer8   r9   r>     s    r   z*Expected at least one Value or Device typer   r?   r)   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )r@   r   r   r   rP   r   rA   )ru   rN   r;   r   r   value_types_namesoptional_devicesget_device_strr8   r   r9   
get_device  s   
z&GenLazyNativeFuncDefinition.get_devicec              
      s  | j |}|d usJ | }t|j}d|jv }|jp!|jd u}|s&|rd}|dkrIdtdt	fdd d
 fd	d
t|D }	d|	 d }t|j}
t|
\}}dd
 t||
 ddD }|rm|jsjJ d}nd}|j}|j r| r|d7 }d| d| d| dd
| d| 
}nt|j|| d}d|j d}|d| d7 }dt	|j }|dd
d d! |D  d"| d#7 }|S )$N	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};   r   r%   c                 S   s   d|  d|  dS )Nztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())r8   )r   r8   r8   r9   
this_shape  s   z?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape,c                    s   g | ]} |qS r8   r8   r   r   r8   r9   r>         z?GenLazyNativeFuncDefinition.shape_inference.<locals>.<listcomp>z'std::vector<torch::lazy::Shape> shapes{z};c                 S   rF   r8   rG   )r=   er8   r8   r9   r>     s    F)method&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r   r   r?   z);
        rp   z
            auto shapes = r   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == r^   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c                 s   s    | ]}t |jV  qd S r   )r   r0   rI   r8   r8   r9   r   2  s    z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )rk   rr   r@   rP   r   tags
structuredstructured_delegateintr   rA   r   r   rM   rN   rh   r   rO   5has_composite_explicit_autograd_non_functional_kernelrQ   
has_symintrs   ComputeShapeSignaturekernel
shape_call)ru   rN   r;   rv   r   returns_lengthis_view_copy_opis_structuredmeta_out
shapes_strrT   meta_conversion_strmeta_call_ctxmeta_call_argsdispatch_nsrQ   	shape_str	shape_sigfunc_schema_strr8   r   r9   shape_inference  sj   





z+GenLazyNativeFuncDefinition.shape_inferencec                 C   s8   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);
        }
        )rC   r   r  )ru   rN   r;   node_ctor_input_strr8   r8   r9   build_ir_node9  s   
z)GenLazyNativeFuncDefinition.build_ir_nodeNfirst_tensor_namec                 C   s8   | j r|d usJ d| d| j S | j d| j S )Nz+Requires first tensor to create lazy tensor.r   )r   r   r   )ru   r
  r8   r8   r9   create_lazy_tensorC  s   
z.GenLazyNativeFuncDefinition.create_lazy_tensorc                 C   s   t |j}|jddd}dd |D }t |dkr|d nd }d| j d| | d	}|d
krUt |dks:J dd| j d| d| | dt  d| j d| d}|jjj	s_|j
 rt|d
kskJ d| dd| d| d}|d7 }|S )NTFr   c                 S   r   r8   r   rI   r8   r8   r9   r>   P  r   zBGenLazyNativeFuncDefinition.return_aten_tensor.<locals>.<listcomp>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;)rP   r   r@   r   r  r   r
   r   r0   inplacerN   	is_out_fn)ru   rN   r;   r   r   r   r
  
bridge_strr8   r8   r9   return_aten_tensorM  sB   



z.GenLazyNativeFuncDefinition.return_aten_tensorc                 C   s   t || j}| j|}|d usJ t|j| d}d|j| j d|j d d| 	|||| d| 
|| d| || d| || d| || d| || dgS )Nrp   z    r   r   z {
        r_   z
    }

    )r   rk   rr   r   rN   rs   declr   r   r   r   r   r   r	  r  )ru   rN   rD   rv   r;   r8   r8   r9   rw   k  s(   




z$GenLazyNativeFuncDefinition.__call__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   rw   r8   r8   r8   r9   r     sH   
 -

K

r   c                   @   sf   e Zd ZdZdededefddZdefdd	Zdefd
dZ	e
defddZe
def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_namero   r7   c                C   s\   t |j|d| _ddd tj|j|dD | _ddd | jjddD | _|| _	d S )Nrp   r?   c                 S   s   g | ]}|  qS r8   )r  rI   r8   r8   r9   r>     r   z2ComputeShapeSignature.__init__.<locals>.<listcomp>c                 S   s   g | ]}|j  qS r8   r   r<   r8   r8   r9   r>     r   T)	generator)
r   rN   _ComputeShapeSignature__schemarA   
dispatcherrO   %_ComputeShapeSignature__dispatch_argsr@   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)ru   r  ro   r7   r8   r8   r9   __init__  s   
zComputeShapeSignature.__init__r%   c                 C      | j  d| j dS Nr   r)   )r  r  ru   r8   r8   r9   __decl_suffix     z#ComputeShapeSignature.__decl_suffixc                 C   r  r  )r  r  r  r8   r8   r9   __call_suffix  r  z#ComputeShapeSignature.__call_suffixc                 C      d|    S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixr  r8   r8   r9   
shape_decl     z ComputeShapeSignature.shape_declc                 C   r!  )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixr  r8   r8   r9   r     r$  z ComputeShapeSignature.shape_callN)r   r   r   __doc__r   r"   r   r  r"  r%  propertyr#  r   r8   r8   r8   r9   r     s    
r   c                   @   s8   e Zd ZU eed< eed< ededee fddZ	dS )GenLazyShapeInferenceDefinitionrk   r   ro   r%   c                 C   st   t || j}| j|}|d usJ d|jv }|jp|jd u}|s#|r%g S t|j|| d}d	|j
 dggS )Nr   rp   
r   )r   rk   rr   r   r   r   r   r   rs   rA   r#  )ru   ro   rD   rv   r   r   r  r8   r8   r9   rw     s   
z(GenLazyShapeInferenceDefinition.__call__N)
r   r   r   r   r   r   r   r"   r   rw   r8   r8   r8   r9   r(    s
   
 r(  
non_nativegen_lazy_irc                 C   st   g }| D ]3}t ddd}|dg D ]}t||d qtt|d |dd}|d|_|||d	  q|S )
z,Generate the non-native lazy IR node classesr   r   r   r   TrN   rp   r   r   )	r   getsetattrr   r    parser   rb   rt   )r*  r+  nodesopr   pr;   r8   r8   r9   !generate_non_native_lazy_ir_nodes  s   r2  );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   rY   rS   rh   rj   r   r   r   r(  r2  r8   r8   r8   r9   <module>   sT      (
,;


 *8 r