U
    •Ê¹jYr  ã                   @   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. ee/dœdd„Z0ee/dœdd„Z1eeeef e/e/dœdd„Z2ee/dœdd„Z3ee
e/ee f dœ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$ƒƒZ9eee/ef  e5ee/ d%œ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ƒrÆt| jtƒrd| jr(d| j› �S | jjtkrBd| j› d�S | jrVd| 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�ƒ‚nät| jtƒ�r| jjttjƒk�r| j� rþd| j› d�S d| j› d| j› d�S n”t| jtƒ�rVt| jjtƒ�rVd| jjj› d| j› d| j› d�S t| jt	ƒ�r¢t| jjtƒ�r¢t| jjjtƒ�r¢d| jjjj› d| j› d�S | j› S dS )z�
    Given a LazyArgument,
    generate a c++ string for materializing an rvalue of that arg for passing into
    a lazy Node constructor.
    Znode_Úlazy_Z_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<N)r   Ú	lazy_typeÚ
isinstancer   Úis_wrapped_scalarÚnameÚtyper   Úis_symint_or_listr   ÚAssertionErrorÚ	orig_typer!   Úelemr   r   ZSymIntÚsymintr   )r$   © r5   úT/var/www/html/bwave/python/venv/lib/python3.8/site-packages/torchgen/dest/lazy_ir.pyÚnode_ctor_arg_rvalue_string)   sL    
ÿÿÿ ÿ"
ÿþýr7   ©Úschemar%   c                 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 r5   )r7   ©Ú.0r$   r5   r5   r6   Ú
<listcomp>h   s    z$node_ctor_inputs.<locals>.<listcomp>ú, )Úfiltered_argsÚjoin)r9   Znode_ctor_valuesr5   r5   r6   Únode_ctor_inputsd   s    ÿr@   )r9   ÚsigÚoverload_namer%   c              	   C   s¤   t  | j¡}t| ¡ | ¡ ƒ}d dd„ |D ƒ¡}t|ƒrPd| j› d|› d�}nd| j› d�}d}| jr‚d	| 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   s   g | ]
}|j ‘qS r5   ©Úexpr©r;   Úar5   r5   r6   r<   x   s     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   Ú	argumentsr?   ÚlenÚ	aten_nameZgenerator_argr.   Úaten_symbol)r9   rA   rB   Údispatcher_sigZexprsZfallback_argsZaten_op_strZor_has_generatorr5   r5   r6   Úgen_fallback_coden   s$    ÿÿþýrO   c                 C   s@   dh}| j |krd| j › d�S | j  d¡s6d| j › �S | j S d S )NZsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rL   Ú
startswith)r9   Zmissing_interned_stringsr5   r5   r6   rM   Š   s    ÿ
rM   )rA   r%   c                 C   s‚   g }g }|   ¡ D ]^}t|jtƒrd|jj ¡ rd|j› d�}| d|› d|j› d�¡ | | |¡¡ q| |¡ qd 	|¡}||fS )NÚ_metazauto z = to_meta(ú);ú	
        )
rJ   r,   Úargumentr   r/   Zis_tensor_liker.   ÚappendÚ	with_namer?   )rA   ÚcontextZunwrapped_tensor_argsr$   Zunwrapped_nameZunwrap_tensor_args_strr5   r5   r6   Úconvert_to_meta_tensorsš   s    ÿ
rX   T)Úfrozenc                   @   s¦   e Zd ZU eed< eed< eed< eed< eee	e
f ee dœdd„ƒZeedœd	d
„Zeeedœdd„Zeeedœdd„Zeedœdd„Zeee dœ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 k	oF| ¡ d�}|  |¡S )N©r4   )	r,   r#   Z
functionalrI   r[   Ú
get_kernelr   Úsupports_symintÚgen)Úselfr`   rI   Úmetadatar9   r5   r5   r6   Ú__call__±   s    ÿ ÿzGenLazyIR.__call__r8   c                 C   s   dS ©NrG   r5   )re   r9   r5   r5   r6   Úlowering_function¾   s    zGenLazyIR.lowering_function©r9   Únode_ctor_argsr%   c                 C   s   dS rh   r5   ©re   r9   rk   r5   r5   r6   Úcreate_functionÁ   s    zGenLazyIR.create_functionc                 C   s   d|› d�S )Núbool CanBeReused(z!) const {
    return false;
    }r5   rl   r5   r5   r6   Úcan_be_reused_functionÄ   s    z GenLazyIR.can_be_reused_functionc           
      C   st  |j ddd�}g }|D ]V}t|jttfƒr:| |j› ¡ qt|jtƒrZ| |j› d�¡ qtd|j› d�ƒ‚qd 	|¡}|j ddd�}|j
jr”d}nš|j
jrÚd	d
„ |D ƒ}| dd„ |D ƒ¡ d|j› dd 	|¡› d�}nT|j
j�r*d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©ÚvaluesZscalarsú.value_or(kNullValue)zUnsupported type (z) - add support if necessaryr=   zstd::move(shapes),c                 S   s   g | ]
}|j ‘qS r5   ©r.   rE   r5   r5   r6   r<   à   s     z1GenLazyIR.node_base_ctor_call.<locals>.<listcomp>c                 s   s   | ]}|j V  qd S ©Nrs   rE   r5   r5   r6   Ú	<genexpr>á   s     z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>Zcompute_shape_ú(z),c                 S   s   g | ]}d |› d�‘qS )zoperand(r'   r5   ©r;   Úir5   r5   r6   r<   ä   s     c                 s   s   | ]}|j V  qd S rt   rs   rE   r5   r5   r6   ru   å   s     z[&](){ return compute_shape_z)[0]; },rG   c                 s   s   | ]}|j › V  qd S rt   rs   rE   r5   r5   r6   ru   ê   s     z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash(ú)))r>   r,   r+   r   r   rU   r.   r   r1   r?   Ú
propertiesÚShapePrecomputeZShapeComputeÚextendÚ
ShapeCacheÚrangerK   r]   Ú	node_nameÚreturns)
re   r9   Ú
value_argsZbase_ctor_value_args_listr$   Zbase_ctor_value_argsÚscalar_argsZshape_ctor_argZ
shape_argsZscalar_hashesr5   r5   r6   Ú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rb|jjrb| d¡ d |¡}d d	d„ |D ƒ¡}	t|	ƒr’d|	› �}	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�	¡ qî| d|j› d|j› d�¡ qîd |¡}d|j› d| j› d|› d|j› d|› d|  |¡› |	› d|› d| j› d|› d |  ||¡› d!|  ||¡› d!|  |¡› d!|
› d
|› d"�gS )#NTFrp   c                 S   s$   g | ]}d |j  ¡ › d|j› �‘qS )zconst z& ©r+   Zcpp_typer.   rw   r5   r5   r6   r<   ü   s     z!GenLazyIR.gen.<locals>.<listcomp>r=   z(std::vector<torch::lazy::Shape>&& shapesz
,
        c                 S   sJ   g | ]B}|j  ¡ d kr2|j› d|j› d|j› d�n|j› d|j› d�‘qS )úc10::optional<c10::string_view>rv   z/.has_value() ? c10::make_optional(std::string(*z)) : c10::nullopt)r'   r„   rE   r5   r5   r6   r<     s   þÿz
  c                 S   s\   g | ]T}|j  ¡ d kr$d|j› d�n2|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„   rE   r5   r5   r6   r<     s   üÿÿc                 S   s   g | ]}t |jtƒr|j‘qS r5   )r,   r+   r   r.   r:   r5   r5   r6   r<     s   þc                 S   s   g | ]}d |› d�‘qS )z	bool has_z: 1;r5   ©r;   Úvaluer5   r5   r6   r<     s     z
    c                 S   s   g | ]}d |› d|› d�‘qS )Zhas_z = !!r†   r5   rˆ   r5   r5   r6   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
);
  }

  rv   z
)
      : z	
  {
    zT
  }

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

  z

  z

};

)ÚopkindrM   r>   r?   r^   rz   r{   rU   rK   r,   r+   r   r.   r   r]   rƒ   rm   ro   ri   )re   r9   rŠ   Úall_argsr�   r‚   Z	ctor_argsZreuse_ctor_argsrk   Zscalar_initializersZscalar_declsZoptional_valuesZhas_optional_declsZhas_optional_defsZmembers_to_stringr$   Zmembers_to_string_strr5   r5   r6   rd   ó   sŒ    


ûÿ	
úÿ
þÿÿ$ÿ
ÿÿüÿùøø
öÿð
ì
êèæåÿzGenLazyIR.genN)Ú__name__Ú
__module__Ú__qualname__r   Ú__annotations__ÚstrÚboolr   r	   r#   r"   r   rg   r   ri   rm   ro   rƒ   rd   r5   r5   r5   r6   rZ   ª   s   
*rZ   c                   @   s@   e Zd Zeedœdd„Zeeedœdd„Zeeedœdd„Zd	S )
ÚGenTSLazyIRr8   c                 C   s:   d}|j jr|› d�S |j jr2|› dt|ƒ› d�S dS d S )Nz˜
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider†   z {
    z
  }
            rG   )rz   ÚLowerDeclOnlyZLowerr   )re   r9   Ú	signaturer5   r5   r6   ri   V  s    
ÿzGenTSLazyIR.lowering_functionrj   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†   rG   z {
    return ReuseOrMakeNode<z>(data);
  })rz   ZCreateFnDeclOnlyZCreateFnr   )re   r9   rk   r”   r5   r5   r6   rm   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 ]8}t|jt	ƒrd| 
d|j› d�¡ q>| 
d|j› �¡ q>t |j|j¡D ]h}t|jt	ƒrÖ| 
d|j› d	|j› d
|j› d|j› d|j› d|j› d�¡ qˆ| 
d|j› d|j› �¡ qˆd |¡}|› d|› d�S )Nrn   z) constr†   rG   znullable_operand(i++) == rr   zoperand(i++) == z	((!this->z&&!z) || (this->z&&z && *(this->z) == *ry   zthis->z == z &&
        z! {
    size_t i = 0;
    return (z);
  })rz   ZCanBeReusedDeclOnlyÚCanBeReusedÚ	itertoolsÚchainZpositional_valuesZkeyword_valuesr,   r+   r   rU   r.   Zpositional_scalarsZkeyword_scalarsr?   )re   r9   rk   r”   Zvalue_comparisonr$   Zvalue_comparison_strr5   r5   r6   ro   p  s,    
ÿ4ÿ
þz"GenTSLazyIR.can_be_reused_functionN)rŒ   r�   rŽ   r   r�   ri   rm   ro   r5   r5   r5   r6   r’   T  s   
r’   c                   @   s>  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< eeedœdd„Z	eee
eeef edœdd„Zeeedœdd„Zeeedœdd„Zeeedœdd„Zeeedœdd„Zd'ee edœd d!„Zeeedœd"d#„Zeeee d$œd%d&„ƒZdS )(ÚGenLazyNativeFuncDefinitionÚclass_method_namer[   Ú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_fn)rI   r9   r%   c                 C   sv  |j ddd�}g }|D �]R}|jrrt|jtƒrT| d|j› d|j› d|j› d�¡ n| d|j› d|j› d	�¡ q|jr|qqt|jtƒrö|jj	t
krÂ| d
|j› d| j› d| j› d|j› d�	¡ n2| | j› d|j› d| j› d| j› d|j› d	�
¡ qt|jtƒ�rX|jjttƒ ƒk�s$t|jjƒ‚| | j› d|j› d| j› d| j› d|j› d�
¡ qtd|j› d�ƒ‚qd |¡S )NTFrp   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 = ú::rv   rR   z lazy_z.value_or(at::Tensor()));r(   r'   rS   )r>   r-   r,   r+   r   rU   r.   r0   r   r/   r   rœ   r�   r¥   rž   r3   r
   r1   rŸ   r?   )re   rI   r9   r�   Úlazy_tensor_declsr$   r5   r5   r6   r¨   Ÿ  s<    
ÿÿ$ÿ*ÿ *ÿÿz-GenLazyNativeFuncDefinition.lazy_tensor_decls)rI   r9   rf   rA   r%   c                 C   s   | j rt|||jjjd�S dS )N)rB   rG   )r›   rO   rI   r.   rB   )re   rI   r9   rf   rA   r5   r5   r6   Úforce_eager_fallbackÌ  s      ÿz0GenLazyNativeFuncDefinition.force_eager_fallbackc                 C   s   | j › d�S )Nr†   )r    )re   rI   r9   r5   r5   r6   ÚmetricsÙ  s    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sht|ƒdkshtdƒ‚| j› d	d
 || ¡› d�}d|› d�S )NTFrp   c                 S   s   g | ]}|j s|j› ‘qS r5   ©r-   r.   rE   r5   r5   r6   r<   ß  s      z:GenLazyNativeFuncDefinition.get_device.<locals>.<listcomp>c                    s   g | ]}|j ˆ kr|j‘qS r5   )r+   r.   rE   ©Zoptional_devicer5   r6   r<   á  s    
 r   z*Expected at least one Value or Device typerv   r=   r'   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )r>   r   r   r   rK   r1   r¦   r?   )re   rI   r9   r�   r‚   Úvalue_types_namesZoptional_devicesZget_device_strr5   r¬   r6   Ú
get_deviceÜ  s     
ÿ
ÿ
ÿþÿz&GenLazyNativeFuncDefinition.get_devicec              
      s’  | j  |¡}|d k	st‚| ¡ }t|jƒ}d|jk}|jpB|jd k	}|sN|�r(d}|dkr’t	t
dœdd„‰ d ‡ fdd	„t|ƒD ƒ¡}	d
|	 d }t |j¡}
t|
ƒ\}}dd	„ t||
 ¡ dd�D ƒ}|rÚ|jsÔt‚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())};é   )rx   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())r5   )rx   r5   r5   r6   Ú
this_shape  s    z?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shapeú,c                    s   g | ]}ˆ |ƒ‘qS r5   r5   rw   ©r±   r5   r6   r<     s     z?GenLazyNativeFuncDefinition.shape_inference.<locals>.<listcomp>z'std::vector<torch::lazy::Shape> shapes{z};c                 S   s   g | ]
}|j ‘qS r5   rC   )r;   Úer5   r5   r6   r<     s   ÿF)ÚmethodZ&compositeexplicitautogradnonfunctionalÚmetaZ_symintz        z
        auto out_meta = at::r§   rv   r=   z);
        ra   z
            auto shapes = r†   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == rR   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c                 s   s   | ]}t |jƒV  qd S rt   )r�   r.   rE   r5   r5   r6   ru   2  s     z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )r[   rb   r1   r>   rK   r€   ÚtagsÚ
structuredÚstructured_delegateÚintr�   r?   r~   r   rH   rI   rX   r   rJ   Z5has_composite_explicit_autograd_non_functional_kernelrL   Z
has_symintrc   ÚComputeShapeSignatureÚkernelÚ
shape_call)re   rI   r9   rf   r‹   Úreturns_lengthÚis_view_copy_opÚis_structuredZmeta_outZ
shapes_strrN   Zmeta_conversion_strZmeta_call_ctxZmeta_call_argsZdispatch_nsrL   Z	shape_strÚ	shape_sigZfunc_schema_strr5   r³   r6   Úshape_inferenceî  sr    


  ÿþ
ÿþþþý  ÿÿÿ
þý
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);
        }
        )r@   r   rÂ   )re   rI   r9   Znode_ctor_input_strr5   r5   r6   Úbuild_ir_node9  s    
þz)GenLazyNativeFuncDefinition.build_ir_nodeN)Úfirst_tensor_namer%   c                 C   s8   | j r&|d k	stdƒ‚|› d| j› �S | j› d| j› �S )Nz+Requires first tensor to create lazy tensorÚ.r§   )r¢   r1   r¡   rœ   )re   rÄ   r5   r5   r6   Ú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rªt |ƒdksttdƒ‚d| j› d|› d|  |¡› dtƒ › d| j› d|› d�}|j	j	j
s¾|j ¡ rè|d
ksÖtd|› d�ƒ‚d|› d|› d�}|d7 }|S )NTFrp   c                 S   s   g | ]}|j s|j› ‘qS r5   r«   rE   r5   r5   r6   r<   P  s      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(rv   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>   r£   rÆ   r1   r¥   r
   r¤   r.   ZinplacerI   Z	is_out_fn)re   rI   r9   r¾   r�   r­   rÄ   Z
bridge_strr5   r5   r6   Úreturn_aten_tensorM  s<    

ÿ
ÿþ
ÿþþüÿ

ÿz.GenLazyNativeFuncDefinition.return_aten_tensor)rI   r%   c                 C   s²   t || jƒ}| j |¡}|d k	s$t‚t|j| ¡ d�}d|j| j› d|j	› �d�› d|  
||||¡› d|  ||¡› d|  ||¡› d|  ||¡› d|  ||¡› d|  ||¡› d�gS )Nra   z    r§   rs   z {
        rS   z
    }

    )r   r[   rb   r1   r   rI   rc   Údeclr™   r¼   r©   rª   r®   r¨   rÃ   rÈ   )re   rI   rA   rf   r9   r5   r5   r6   rg   k  s(    ÿþ
ý
ü
û
ú
ùÿz$GenLazyNativeFuncDefinition.__call__)N)rŒ   r�   rŽ   r�   r�   r   r‘   r"   r   r¨   r   r	   r   r   r©   rª   r®   rÂ   rÃ   r   rÆ   rÈ   r   r   rg   r5   r5   r5   r6   r˜   �  s<   
/
úK

r˜   c                   @   sb   e Zd ZdZeeedœdd„Zedœdd„Zedœdd	„Z	e
edœd
d„ƒZe
edœ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`   r4   c                C   s\   t |j|d�| _d dd„ tj|j|d�D ƒ¡| _d dd„ | jjdd�D ƒ¡| _|| _	d S )Nra   r=   c                 S   s   g | ]}|  ¡ ‘qS r5   )rÉ   rE   r5   r5   r6   r<   ‡  s     z2ComputeShapeSignature.__init__.<locals>.<listcomp>c                 S   s   g | ]}|j › ‘qS r5   rs   r:   r5   r5   r6   r<   Š  s     T)Ú	generator)
r   rI   Z_ComputeShapeSignature__schemar?   Ú
dispatcherrJ   Ú%_ComputeShapeSignature__dispatch_argsr>   Ú!_ComputeShapeSignature__call_argsÚ#_ComputeShapeSignature__kernel_name)re   rÊ   r`   r4   r5   r5   r6   Ú__init__„  s    ÿÿzComputeShapeSignature.__init__)r%   c                 C   s   | j › d| j› d�S ©Nrv   r'   )rÏ   rÍ   ©re   r5   r5   r6   Z__decl_suffixŽ  s    z#ComputeShapeSignature.__decl_suffixc                 C   s   | j › d| j› d�S rÑ   )rÏ   rÎ   rÒ   r5   r5   r6   Z__call_suffix‘  s    z#ComputeShapeSignature.__call_suffixc                 C   s   d|   ¡ › �S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)Ú#_ComputeShapeSignature__decl_suffixrÒ   r5   r5   r6   Ú
shape_decl”  s    z ComputeShapeSignature.shape_declc                 C   s   d|   ¡ › �S )Nztorch::lazy::compute_shape_)Ú#_ComputeShapeSignature__call_suffixrÒ   r5   r5   r6   r½   ˜  s    z ComputeShapeSignature.shape_callN)rŒ   r�   rŽ   Ú__doc__r�   r"   r‘   rÐ   rÓ   rÕ   ÚpropertyrÔ   r½   r5   r5   r5   r6   r»     s   
r»   c                   @   s6   e Zd ZU eed< eed< eeee dœdd„ƒZ	dS )ÚGenLazyShapeInferenceDefinitionr[   rš   r_   c                 C   sx   t || jƒ}| j |¡}|d k	s$t‚d|jk}|jp<|jd k	}|sF|rJg S t|j|| 	¡ d�}d 
|j› d�g¡gS d S )Nr¯   ra   Ú
r†   )r   r[   rb   r1   r·   r¸   r¹   r»   r¼   rc   r?   rÔ   )re   r`   rA   rf   r¿   rÀ   rÁ   r5   r5   r6   rg   ¢  s    
  ÿz(GenLazyShapeInferenceDefinition.__call__N)
rŒ   r�   rŽ   r   r�   r�   r   r"   r   rg   r5   r5   r5   r6   rØ   �  s   
rØ   )Ú
non_nativeÚgen_lazy_irr%   c                 C   st   g }| D ]f}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“   rz   TrI   ra   rŠ   r   )	r   ÚgetÚsetattrr   r    ÚparserŠ   rU   rd   )rÚ   rÛ   ZnodesÚoprz   Úpr9   r5   r5   r6   Ú!generate_non_native_lazy_ir_nodes´  s    rá   );r–   Úabcr   Údataclassesr   Útypingr   r   r   r   r   r	   Ztorchgen.api.dispatcherÚapirÌ   Ztorchgen.api.lazyr
   r   r   r   r   r   Ztorchgen.api.translater   Ztorchgen.api.typesr   r   r   r   r   r   r   r   Ztorchgen.contextr   Ztorchgen.dest.lazy_ts_loweringr   Ztorchgen.modelr   r   r   r   r   r    r!   r"   r#   r�   r7   r@   rO   rM   rX   rZ   r’   r˜   r»   rØ   rá   r5   r5   r5   r6   Ú<module>   sD     (
,;
ü *8 r þ