o
    h>q                     @  s  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
  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+ d3ddZ,d4ddZ-d5ddZ.d4ddZ/d6dd Z0ed!d"G d#d$ d$eZ1ed!d"G d%d& d&e1Z2ed!d"G d'd( d(Z3G d)d* d*Z4ed!d"G d+d, d,Z5d7d1d2Z6dS )8    )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                 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& ? 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     r5   i/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_string+   sN   

"
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>j   s    z$node_ctor_inputs.<locals>.<listcomp>, )filtered_argsjoin)r8   node_ctor_valuesr5   r5   r6   node_ctor_inputsf   s   
r@   sig%DispatcherSignature | NativeSignatureoverload_namec                 C  sz   t | j}t| | }d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                 S     g | ]}|j qS r5   exprr:   ar5   r5   r6   r;   z       z%gen_fallback_code.<locals>.<listcomp>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   	argumentsr>   len	aten_nameaten_symbol)r8   rA   rC   dispatcher_sigexprsfallback_argsaten_op_strr5   r5   r6   gen_fallback_codep   s   rT   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::)rN   
startswith)r8   missing_interned_stringsr5   r5   r6   rO      s   
rO   r   tuple[str, list[Binding]]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();	
        )
rL   r+   argumentr   r.   is_tensor_liker-   append	with_namer>   )rA   contextunwrapped_tensor_argsr    unwrapped_nameunwrap_tensor_args_strr5   r5   r6   convert_to_meta_tensors   s   
rd   T)frozenc                   @  sn   e Zd ZU ded< ded< ded< ded< edddZdddZdddZdddZdddZ	dddZ
dS ) 	GenLazyIRr   backend_indexr"   backend_name	node_basebooluse_lazy_shapef%NativeFunctionsGroup | NativeFunctionr!   	list[str]c                 C  sV   t |tr	|jjn|j}| jt |tr|jn|}t||d uo#| d}| |S )Nr4   )	r+   r   
functionalrK   rg   
get_kernelr
   supports_symintgen)selfrl   rK   metadatar8   r5   r5   r6   __call__   s   
zGenLazyIR.__call__r8   r
   c                 C     dS N r5   )rt   r8   r5   r5   r6   lowering_function      zGenLazyIR.lowering_functionnode_ctor_argsc                 C  rw   rx   r5   rt   r8   r|   r5   r5   r6   create_function   r{   zGenLazyIR.create_functionc                 C  s   d| dS )Nbool CanBeReused(z!) const {
    return false;
    }r5   r}   r5   r5   r6   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  rD   r5   r-   rG   r5   r5   r6   r;      rI   z1GenLazyIR.node_base_ctor_call.<locals>.<listcomp>c                 s      | ]}|j V  qd S Nr   rG   r5   r5   r6   	<genexpr>       z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>compute_shape_(z),c                 S     g | ]}d | dqS )zoperand(r&   r5   r:   ir5   r5   r6   r;          c                 s  r   r   r   rG   r5   r5   r6   r      r   z[&](){ return compute_shape_z)[0]; },ry   c                 s  s    | ]}|j  V  qd S r   r   rG   r5   r5   r6   r      s    z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))r=   r+   r*   r   r   r^   r-   r   r0   r>   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerM   ri   	node_namereturns)
rt   r8   
value_argsbase_ctor_value_args_listr    base_ctor_value_argsscalar_argsshape_ctor_arg
shape_argsscalar_hashesr5   r5   r6   node_base_ctor_call   sF   
zGenLazyIR.node_base_ctor_callc                 C  s  |j pt|}| }|jddd}dd |D }d|}| jr*|jjr*|d d|}dd	d |D }t|rBd| }d
dd |D }	dd |jdddD }
d
dd |
D }ddd |
D }g }|D ]7}t	|j
tr|j d}|jrd}|d|j d|j d| d|j d	 qp|d|j d|j d qpd|}d|j d| j d| d|j d| d| | | d| d | j d!| d"| || d#| || d#| | d#|	 d
| d$gS )%NFTr   c                 S  s$   g | ]}d |j   d|j qS )zconst z& r*   cpp_typer-   r   r5   r5   r6   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 )!::std::optional<c10::string_view>r   z1.has_value() ? ::std::make_optional(std::string(*z)) : ::std::nullopt)r&   r   rG   r5   r5   r6   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::std::optional<std::string>  r   rG   r5   r5   r6   r;     s    c                 S  s   g | ]}t |jtr|jqS r5   )r+   r*   r   r-   r9   r5   r5   r6   r;     s    
c                 S  r   )z	bool has_z: 1;r5   r:   valuer5   r5   r6   r;     r   z
    c                 S  s   g | ]}d | d| dqS )has_z = !!r   r5   r   r5   r5   r6   r;     s    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

};

)opkindrO   r=   r>   rk   r   r   r^   rM   r+   r*   r   r-   is_generatorr   ri   r   r~   r   rz   )rt   r8   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_strr5   r5   r6   rs      s   


	






zGenLazyIR.genN)rl   rm   r!   rn   r8   r
   r!   r"   r8   r
   r|   r"   r!   r"   )r8   r
   r!   rn   )__name__
__module____qualname____annotations__r   rv   rz   r~   r   r   rs   r5   r5   r5   r6   rf      s   
 



*rf   c                   @  s*   e Zd ZdddZddd	Zdd
dZdS )GenTSLazyIRr8   r
   r!   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
  }
            ry   )r   LowerDeclOnlyLowerr   )rt   r8   	signaturer5   r5   r6   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   ry   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )rt   r8   r|   r   r5   r5   r6   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   ry   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   r^   r-   positional_scalarskeyword_scalarsr>   )rt   r8   r|   r   value_comparisonr    value_comparison_strr5   r5   r6   r   p  s,   
4
z"GenTSLazyIR.can_be_reused_functionNr   r   )r   r   r   rz   r~   r   r5   r5   r5   r6   r   T  s    


r   c                   @  s   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< d2ddZd3ddZd2d d!Zd2d"d#Zd2d$d%Zd2d&d'Z	d4d5d+d,Z
d2d-d.Zed6d0d1Zd(S )7GenLazyNativeFuncDefinitionr"   class_method_namer   rg   tensor_classrj   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_fnrK   r   r8   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 ?
                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   rZ   z lazy_z.value_or(at::Tensor()));r'   r&   r[   )r=   r,   r+   r*   r   r^   r-   r/   r   r.   r   r   r   r   r   r2   r   r   r0   r>   )rt   rK   r8   r   lazy_tensor_declsr    r5   r5   r6   r     sh   


z-GenLazyNativeFuncDefinition.lazy_tensor_declsru   r   rA   rB   c                 C  s   | j rt|||jjjdS dS )N)rC   ry   )r   rT   rK   r-   rC   )rt   rK   r8   ru   rA   r5   r5   r6   force_eager_fallback  s
   z0GenLazyNativeFuncDefinition.force_eager_fallbackc                 C  s   | j  dS )Nr   )r   )rt   rK   r8   r5   r5   r6   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 r5   r,   r-   rG   r5   r5   r6   r;         z:GenLazyNativeFuncDefinition.get_device.<locals>.<listcomp>c                   s   g | ]
}|j  kr|jqS r5   )r*   r-   rG   optional_devicer5   r6   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   rM   r   r>   )rt   rK   r8   r   r   value_types_namesoptional_devicesget_device_strr5   r   r6   
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rEd&dd	 d
 fddt	|D }	d|	 d }t
|j}
t|
\}}dd t||
 ddD }|ri|jsfJ 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   intr!   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   )r   r5   r5   r6   
this_shape  s   z?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape,c                   s   g | ]} |qS r5   r5   r   r   r5   r6   r;         z?GenLazyNativeFuncDefinition.shape_inference.<locals>.<listcomp>z'std::vector<torch::lazy::Shape> shapes{z};c                 S  rD   r5   rE   )r:   er5   r5   r6   r;     s    F)method&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r   r   r<   z);
        ro   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                 s  s    | ]}t |jV  qd S r   )r"   r-   rG   r5   r5   r6   r   2  s    z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )r   r   r!   r"   )rg   rq   r=   rM   r   tags
structuredstructured_delegater>   r   r   rJ   rK   rd   r   rL   5has_composite_explicit_autograd_non_functional_kernelrN   
has_symintrr   ComputeShapeSignaturekernel
shape_callr"   )rt   rK   r8   ru   r   returns_lengthis_view_copy_opis_structuredmeta_out
shapes_strrP   meta_conversion_strmeta_call_ctxmeta_call_argsdispatch_nsrN   	shape_str	shape_sigfunc_schema_strr5   r   r6   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);
        }
        )r@   r   r  )rt   rK   r8   node_ctor_input_strr5   r5   r6   build_ir_node9  s   
z)GenLazyNativeFuncDefinition.build_ir_nodeNfirst_tensor_name
str | Nonec                 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   )rt   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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   r5   r   rG   r5   r5   r6   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;)rM   r   r=   r   r  r   r   r   r-   inplacerK   	is_out_fn)rt   rK   r8   r   r   r   r  
bridge_strr5   r5   r6   return_aten_tensorM  sB   



z.GenLazyNativeFuncDefinition.return_aten_tensorrn   c                 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 )Nro   z    r   r   z {
        r[   z
    }

    )r   rg   rq   r
   rK   rr   declr   r   r   r   r   r   r
  r  )rt   rK   rA   ru   r8   r5   r5   r6   rv   k  s(   




z$GenLazyNativeFuncDefinition.__call__)rK   r   r8   r
   r!   r"   )
rK   r   r8   r
   ru   r   rA   rB   r!   r"   r   )r  r  r!   r"   )rK   r   r!   rn   )r   r   r   r   r   r   r   r   r  r
  r  r  r   rv   r5   r5   r5   r6   r     s4   
 

-



K


r   c                   @  sJ   e Zd ZdZdd
dZdddZdddZedddZ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"   rl   r   r4   rj   r!   Nonec                C  s\   t |j|d| _ddd tj|j|dD | _ddd | jjddD | _|| _	d S )Nro   r<   c                 S  s   g | ]}|  qS r5   )r  rG   r5   r5   r6   r;     r   z2ComputeShapeSignature.__init__.<locals>.<listcomp>c                 S  s   g | ]}|j  qS r5   r   r9   r5   r5   r6   r;     r   T)	generator)
r
   rK   _ComputeShapeSignature__schemar>   
dispatcherrL   %_ComputeShapeSignature__dispatch_argsr=   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)rt   r  rl   r4   r5   r5   r6   __init__  s   
zComputeShapeSignature.__init__c                 C     | j  d| j dS Nr   r&   )r  r  rt   r5   r5   r6   __decl_suffix     z#ComputeShapeSignature.__decl_suffixc                 C  r  r  )r  r  r   r5   r5   r6   __call_suffix  r"  z#ComputeShapeSignature.__call_suffixc                 C     d|    S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixr   r5   r5   r6   
shape_decl     z ComputeShapeSignature.shape_declc                 C  r$  )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixr   r5   r5   r6   r     r'  z ComputeShapeSignature.shape_callN)r  r"   rl   r   r4   rj   r!   r  )r!   r"   )
r   r   r   __doc__r  r%  r(  propertyr&  r   r5   r5   r5   r6   r     s    



r   c                   @  s,   e Zd ZU ded< ded< edd	d
ZdS )GenLazyShapeInferenceDefinitionr   rg   r"   r   rl   r   r!   rn   c                 C  sh   | 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   ro   
r   )
rg   rq   r   r   r   r   r   rr   r>   r&  )rt   rl   ru   r   r   r  r5   r5   r6   rv     s   
z(GenLazyShapeInferenceDefinition.__call__N)rl   r   r!   rn   )r   r   r   r   r   rv   r5   r5   r5   r6   r+    s
   
 r+  
non_nativelist[dict[str, Any]]gen_lazy_irrn   c                 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   TrK   ro   r   r   )	r	   getsetattrr
   r   parser   r^   rs   )r-  r/  nodesopr   pr8   r5   r5   r6   !generate_non_native_lazy_ir_nodes  s   r6  )r    r   r!   r"   r   )r8   r
   rA   rB   rC   r"   r!   r"   )rA   r   r!   rX   )r-  r.  r/  rf   r!   rn   )7
__future__r   r   abcr   dataclassesr   typingr   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   r7   r@   rT   rO   rd   rf   r   r   r   r+  r6  r5   r5   r5   r6   <module>   s:     (
,

;



 ,8 r