
    Χgǟ                       d dl mZ d dlZd dlZd dlmZ d dlmZmZ d dl	m
c mZ d dlm
c mZ d dlm
c 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mZmZmZ d dlm Z m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, d d	l-m.Z.m/Z/m0Z0 erd d
l1m2Z2 d dZ3d!dZ4d"dZ5d"dZ6d"dZ7d"dZ8d"dZ9 ed           G d d                      Z: ed           G d de:                      Z;dS )#    )annotationsN)	dataclass)LiteralTYPE_CHECKING)	translate)	BaseCTypeBindingConstRefCTypeCppSignatureCppSignatureGroupDispatcherSignatureExprkernel_signatureMutRefCType
NamedCTypeNativeSignaturetensorT)method_with_native_functionnative_function_manager)
ArgumentBackendIndexDeviceCheckTypeDispatchKey"gets_generated_out_inplace_wrapperis_cuda_dispatch_keyNativeFunctionNativeFunctionsGroup
SchemaKindTensorOptionsArguments)assert_nevermapMaybeTarget)SelectiveBuilderbackend_indexr   per_operator_headersboolrocmreturn	list[str]c                   |rdg}ndg}| j         t          j        t          j        fv r|                    d           n| j         t          j        k    r.|r|                    d           n|                    d           nu| j         t          j        k    r|                    d           nJ| j         t          j        k    r|                    d           n|r|g dz  }n|                    d	           |                    d
           |S )Nz'#include <ATen/ops/as_strided_native.h>z!#include <ATen/NativeFunctions.h>z#include <ATen/EmptyTensor.h>z!#include <ATen/hip/EmptyTensor.h>z"#include <ATen/cuda/EmptyTensor.h>z!#include <ATen/mps/EmptyTensor.h>z!#include <ATen/xpu/EmptyTensor.h>)z#include <ATen/ops/empty.h>z##include <ATen/ops/empty_strided.h>z+#include <ATen/ops/_copy_from_and_resize.h>z #include <ATen/ops/_copy_from.h>z#include <ATen/Functions.h>z#include <c10/macros/Macros.h>)dispatch_keyr   CPUMetaappendCUDAMPSXPU)r$   r%   r'   headerss       _/var/www/html/ai-engine/env/lib/python3.11/site-packages/torchgen/dest/register_dispatch_key.pygen_registration_headersr4   .   s.   
  8<=67!ko{7G%HHH67777		#{'7	7	7 	ANN>????NN?@@@@		#{	6	6:;;;;		#{	6	6:;;;;	 6 
 
 
 	
 	4555NN3444N    tuple[str | None, str | None]c                f   d }d }| j         t          j        t          j        t          j        t          j        t          j        fv r1t          | j                                                   }d| }d| }n9| j         t          j	        t          j
        t          j        t          j        fv rd}d}||fS )Nzat::detail::empty_zat::detail::empty_strided_z	at::emptyzat::empty_strided)r+   r   r-   r,   r/   r0   r1   strlower&CompositeExplicitAutogradNonFunctionalQuantizedCPUQuantizedCUDA)r$   
empty_implempty_strided_impldispatchs       r3   gen_empty_impl_namesr@   R   s     J!&   }12288::4(44
D(DD		#: !	( 
 
 !
0)))r5   c           	         | j         t          j        k    rd}nd}t          |           \  }}|g S d| d| d| d| d	gS )Nzoptions.device(at::kMeta)optionsz
Tensor create_out(IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (strides.empty()) {
      return z(sizes, z);
  } else {
      return z(sizes, strides, z	);
  }
}
)r+   r   r-   r@   )r$   empty_optionsr=   r>   s       r3   gen_create_out_helperrD   n   s    ![%5553!%9-%H%H"J"		 	 	 #0	 	
 !	 	
 4A	 	 	
 
r5   c                <    t          |           \  }}|g nd| dgS )Nz
std::optional<Tensor> maybe_create_proxy(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (out.strides() != strides) {
    return z8(sizes, strides, options);
  }
  return std::nullopt;
}
)r@   )r$   _r>   s      r3   gen_maybe_create_proxy_helperrG      sG    0??A % 	   	
r5   c                6    | j         t          j        k    rg S dgS )Na  
void resize_out(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  TORCH_CHECK(options.dtype() == out.dtype(),
      "Expected out tensor to have dtype ", options.dtype(), ", but got ", out.dtype(), " instead");
  TORCH_CHECK(options.device() == out.device(),
      "Expected out tensor to have device ", options.device(), ", but got ", out.device(), " instead");
  const bool resized = at::native::resize_output(out, sizes);
  // Only restride if a resize occurred; otherwise we ignore the (advisory)
  // strides from the meta function and directly use the output tensor's
  // preexisting strides
  if (resized) {
    if (!strides.empty()) {
      TORCH_INTERNAL_ASSERT(!options.memory_format_opt().has_value());
      // TODO: avoid the redispatch here
      out.as_strided_(sizes, strides);
    } else if (options.memory_format_opt().has_value()) {
      out.unsafeGetTensorImpl()->empty_tensor_restride(*options.memory_format_opt());
    }
  }
}
)r+   r   r:   r$   s    r3   gen_resize_out_helperrJ      s)    ![%WWW 		 r5   c                    dgS )Na  
void check_inplace(const Tensor &self, IntArrayRef sizes, const TensorOptions &options) {
  // These checks are needed on those operators that:
  //   1) don't use 'TensorIterator' (e.g. 'addmm' and 'baddbmm')
  //   2) have particular typing rules (e.g. 'cumsum' and 'cumprod')
  // For other operators (e.g. 'add'), 'TensorIterator' already checks
  // these things separately.
  TORCH_CHECK(options.dtype() == self.dtype(),
      "Bad in-place call: ",
      "input tensor dtype ", self.dtype(), " and output tensor dtype ", options.dtype(), " should match");
  TORCH_CHECK(options.device() == self.device(),
      "Bad in-place call: ",
      "input tensor device ", self.device(), " and output tensor device ", options.device(), " should match");
  TORCH_CHECK(sizes == self.sizes(),
      "Bad in-place call: ",
      "input tensor size ", self.sizes(), " and output tensor size ", sizes, " should match");
}
 rI   s    r3   gen_check_inplace_helperrM      s    	 r5   c                    dgt          |           t          |           t          |           t          |           dS )Nz?C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function")zC10_DIAGNOSTIC_POP())rD   rJ   rM   rG   rI   s    r3   gen_registration_helpersrO      s_    I	}	-	- 
}	-	- 
"-	0	0	
 
'}	5	5 	 r5   T)frozenc                      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<   ed#d            Zed$d            Zd%dZd&dZ	d'd Z
	 d(d&d"Zd!S ))RegisterDispatchKeyr   r$   zvLiteral[Target.ANONYMOUS_DEFINITION, Target.NAMESPACED_DEFINITION, Target.NAMESPACED_DECLARATION, Target.REGISTRATION]targetr#   selectorr&   r'   symint
str | Noneclass_method_nameskip_dispatcher_op_registrationtyper   argslist[Argument]method_namer8   r(   c           	         | t           j        k    rdS d}|dz  }|D ]4}|j                                        r|d|j         d| d|j         dz  }5|S )N  // No device check
z4std::optional<Device> common_device = std::nullopt;
z9(void)common_device; // Suppress unused variable warning
z<
  c10::impl::check_and_update_common_device(common_device, z, "z", "z");)r   NoCheckrY   is_tensor_likename)rY   rZ   r\   device_checkargs        r3   gen_device_checkz$RegisterDispatchKey.gen_device_check  s     ?***++NTT 	j 	jCx&&(( j !j<?H!j !jIT!j !jZ]Zb!j !j !j jr5   f%NativeFunctionsGroup | NativeFunctionr)   c                V    t          |t                    rQ|j        r                               S t	          t           fd                                                    S t          |t                    r                     |          }|g n|gS t          |           d S )Nc                0                         |           S Ngen_unstructuredre   gselfs    r3   <lambda>z.RegisterDispatchKey.__call__.<locals>.<lambda>&  s    t'<'<Q'B'B r5   )

isinstancer   
structuredgen_structuredlistr!   	functionsr   rk   r    )rn   re   rrm   s   `  @r3   __call__zRegisterDispatchKey.__call__  s    a-.. 	&'A | **1---BBBBBAKKMMRR   >** 	%%a((A22+OOOOOr5   r   %NativeSignature | DispatcherSignaturec                    t          j        |j        d| j        j         d|j        j        j         d| j                  S )Nwrapper_rF   prefixrU   )r   from_schemafuncr$   r+   ra   overload_namerU   )rn   re   s     r3   wrapper_kernel_sigz&RegisterDispatchKey.wrapper_kernel_sig.  sK     #.F\d0=\\@Y\\\;
 
 
 	
r5   rm   NativeFunctionsGroup | Nonec                   |d S |j                                         }|t          j        u rdn |t          j        u rdnt          d          |                     |          }|                                }| dt          j	        |          }t          |          dk    rod                    fdt          |          D                       }|                                                                 dd	                    |           d
}nt          |          dk    r|d         }	 d d	|	 d}|	}n{t          |j         j        j                  dk    sJ d}|j         j        j        d         }
|
j                                        rd d d d|
j         d	}n d d	|
j         d}|                     |j                  }|                                }|                    |           d d|                                 dd	                    d t)          |                                |                                          D                        d| d| dS )Nzat::_copy_fromzat::_copy_from_and_resizez1gen_out_inplace_wrapper called on a functional op_tmp   z
  c           	   3  :   K   | ]\  }} d | d d| dV  dS )z
(std::get<z>(z), );NrL   ).0iret_namecopy_opfunc_ress      r3   	<genexpr>z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>K  s\       " "Ax DDaDD8DDDDD" " " " " "r5   (, )r   r    z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }ra   z
 {
  auto z = c              3  $   K   | ]}|j         V  d S ri   exprr   es     r3   r   z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>e  s$      6~6~!qv6~6~6~6~6~6~r5   z);
  

  return ;
}
)r}   kindr   inplaceoutAssertionErrorr   ra   cppreturn_nameslenjoin	enumeratereturns_typecpp_type	argumentsrY   is_list_like
functionaldefnr   )rn   re   rm   ksigra   r   updatesreturnsr   out_argfunctional_sigwrapper_namer   r   s                @@r3   gen_out_inplace_wrapperz+RegisterDispatchKey.gen_out_inplace_wrapper8  s    94FKKMM
"""&GG*.  1GG !TUUU%%a((xxzz==='**|q  kk " " " " "#,\#:#:" " "  G ))++4466SS<9P9PSSSGG!###AH ;;8;;x;;;GGGqv'+,,1111Gf&*1-G|((** D
%
 
	
 

 
"),
 
 

 %CCxCC7<CCC00>>xxzz |  #((** -1YY6~6~yQTQ^Q^Q`Q`bpbzbzb|b|G}G}6~6~6~-~-~    	   	r5   r   c           
          j                                       } j         j        t          j        k    r* j                             j                  r
J d            n j         j        t          j        k    r* j                             j                  r
J d            n<||j        s3t          t           fd                                                    S t           j          j         j         j         j         j         j                  }t          t          |j                                                            S )NzqDo not explicitly specify Meta dispatch key on structured functions, they will be automatically generated for youzDo not explicitly specify CompositeExplicitAutograd dispatch key on structured functions, they will be automatically generated for youc                0                         |           S ri   rj   rl   s    r3   ro   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>{  s    4+@+@A+F+F r5   )r$   
get_kernelr+   r   r-   
has_kernelr   r:   rq   rs   r!   rt   StructuredRegisterDispatchKeyrS   rT   r'   rU   rW   rX   gen_one)rn   rm   metadatastructured_gens   ``  r3   rr   z"RegisterDispatchKey.gen_structuredk  s[   %0033*k.>>>)44QU;;  J   
 +AB B )44QU;;  J    X%8!F!F!F!F!FVVWWW6KMIK"0	
 	
 H^3Q[[]]CCDDDr5   Nc                J   t          |          5  d}d}| j                            |          s| j        j        t          j        k    rL|j                                        t          j	        u r'|j
        s t          |j        j                  dk    rd}n5| j        j        s|t          ||| j                  rd}n	 d d d            d S |j        r	 d d d            d S | j        t"          j        u r(| j                            |          s	 d d d            d S |                     |                                          }                                                                }                                }d                    d |D                       }t7          j        |dd          }	| j        t"          j        u rId}
|	                    | j                  D ]}|
d	|                                  d
z  }
|
cd d d            S | j        t"          j!        u rBd+fd}d}
|	                    | j                  D ]}|
 ||          z  }
|
cd d d            S | j        t"          j"        u r|rL|j        j        j#        J |j        j        j#        j$        j        }d| d| d| d| d| dcd d d            S |r"| %                    ||          cd d d            S | j        &                    |          }|	 d d d            d S | j'        |j(         d|j)         }n|j(         d| j'         d|j)         }tU          || j                  }d                    d tW                                          |                                d          D                       }d}| j        j,        rat[          j.        |j        j        j/        |j        j        j0                  }tb          2                    |j3        ti          |          |          }d}|j,        r| j        j,        rtk          d |j        j        j6        D                       }|r!d}to          | j        j                  rd| }n|j        j        j#        |j        j        j#        j$        gng }t[          j.        ||j        j        j/        |j        j        j0                  }tq          d |D             d           }|d| d }d!| d| d| d"| d#| d$| d| d%cd d d            S | j        t"          j        u rA|j        s| j9        r	 d d d            d S d&| d'}d(|j        j         d)| d*cd d d            S tu          | j                   	 d d d            d S # 1 swxY w Y   d S ),NFr   Tr   c              3  >   K   | ]}|                                 V  d S ri   )r   r   as     r3   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s*       8 8a 8 8 8 8 8 8r5   methodfallback_bindingr   rU   
TORCH_API ;
cpp_sigr   r(   r8   c                   d|                                   d                                 dd                    d t          |                                                                           D                        dS )N

 {
return r   r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>  $      __!qv______r5   );
}
r   ra   r   r   r   r   r   s    r3   generate_defnz;RegisterDispatchKey.gen_unstructured.<locals>.generate_defn  s     

 YY__y9J9J9L9Lcmmoo/^/^_____   r5   r    r   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return r   z::c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s8       + + F+ + + + + +r5   r   r^   z// DeviceGuard omittedc              3  @   K   | ]}t          |t                    V  d S ri   )rp   r   r   s     r3   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  sA       - - #1&<==- - - - - -r5   z=
  const DeviceGuard device_guard(device_or_default(device));z globalContext().lazyInitCUDA();
c              3  X   K   | ]%}|j                                         |j         V  &d S ri   )rY   r`   ra   r   s     r3   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  sN        $%#$6#8#8#:#:#$6     r5   z1const OptionalDeviceGuard device_guard(device_of());znamespace {

z) {
  z

  r   z);
}

} // anonymous namespace
z	TORCH_FN(r   m.impl("z",
z);
r   r   r(   r8   );r   r$   r   r+   r   r-   r}   r   r   r   has_composite_kernelr   r   use_out_as_primaryr   manual_kernel_registrationrS   r"   REGISTRATIONrT   is_native_function_selectedr   ra   r   r   r   r   r   from_native_functionNAMESPACED_DECLARATION
signaturesrU   declNAMESPACED_DEFINITIONANONYMOUS_DEFINITIONself_argargumentr   r   rW   cpp_namespacekernelr   r   device_guard	itertoolschainr   flat_positionalrR   rd   rb   rs   anynon_outr   nextrX   r    )rn   re   rm   inplace_metagets_out_inplace_wrapperra   r   rZ   args_strcpp_sig_groupresultr   r   self_arg_namer   	impl_name
kernel_sigargs_exprs_strrb   device_check_argsr   has_tensor_optionsr   candidate_args	device_ofpayloadr   s                             @r3   rk   z$RegisterDispatchKey.gen_unstructured  s    %Q'' n	* n	* L',$%0033  &3{7GGG);;; . < ''1,,#'LL*= :1aASTT & 04,,/n	* n	* n	* n	* n	* n	* n	* n	*0 + 3n	* n	* n	* n	* n	* n	* n	* n	*8 v222AA!DD 3 ?n	* n	* n	* n	* n	* n	* n	* n	*B ))!,,C88::D++--6688L==??Dyy 8 84 8 8 888H .B%%  M
 {f;;;,77t{7KK ? ?G>7<<>>>>>>FFen	* n	* n	* n	* n	* n	* n	* n	*f  <<<      ,77t{7KK 5 5GmmG444FFn	* n	* n	* n	* n	* n	* n	* n	*B  ;;; 
6+4@@@$%F$4$=$F$KM   ,  	  On	* n	* n	* n	* n	* n	* n	* n	*` , >771==cn	* n	* n	* n	* n	* n	* n	* n	*f  -88;;#kn	* n	* n	* n	* n	* n	* n	* n	*l )1#+#9 N NX_ N NII#+#9 h hT=S h hW_Wf h hI-a1CDD
!% + +&)=)=)?)?  + + + " "  8%2 (1(,af.>.N) )% $7#G#G->(?(?$ $L  8> )nd&8&E )n), - -!"!1!9- - - * *& * $n(@ 00B0OPP  RL R R )  !v/8D V-6?@@!# !
 *3$F,0F,<* * %) )7  
 !% %	 %0+m_h+m+m+mL        	      %  un	* n	* n	* n	* n	* n	* n	* n	*N  333/ E43W ESn	* n	* n	* n	* n	* n	* n	* n	*V 2$111GDafkDDwDDDYn	* n	* n	* n	* n	* n	* n	* n	*\ T[))))]n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	* n	*sX   B-VV .VC(VAV%AVV+VH V""VV6VVV)rY   r   rZ   r[   r\   r8   r(   r8   )re   rf   r(   r)   )re   r   r(   rw   )re   r   rm   r   r(   rV   )rm   r   r(   r)   ri   )__name__
__module____qualname____annotations__staticmethodrd   r   rv   r   r   rr   rk   rL   r5   r3   rR   rR      s             JJJ
 LLL "!!! *)))   \ !   ! "
 
 
 
1 1 1 1fE E E E< CGq* q* q* q* q* q* q*r5   rR   c                  R    e Zd ZU ded<   dd
ZddZddZddZedd            Z	dS )r   r   rm   r   r   parent_classr8   generate_superr&   r(   c                j     |r| dndd fd}d	 |d
d           d	 |dd           d	S )NzE::set_output_raw_strided(output_idx, sizes, strides, options, names);r   ra   r8   maybe_create_proxyr&   r(   c           	         d|  dt          j                            |          d           dt          j        d           dS )Nz
void set_output_z|(
    int64_t output_idx, IntArrayRef sizes, IntArrayRef strides,
    TensorOptions options, DimnameList names
) override {
    z
    if (!names.empty()) {
      namedinference::propagate_names(outputs_[output_idx], names);
    }
    // super must happen after, so that downstream can use maybe_get_output
    // to retrieve the output

}
)textwrapindentgen_class_set_output_body)ra   r   r   rn   set_output_supers     r3   gen_set_output_functionz]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionO  sg     
 
//3EFFOO  
!6**   r5   r   stridedT)r   raw_stridedF)ra   r8   r   r&   r(   r8   rL   )rn   r   r   r   r  r  s   ``   @r3   gen_class_set_output_functionsz<StructuredRegisterDispatchKey.gen_class_set_output_functionsG  s      	"".uuu!	 	 	 	 	 	 	 	 t<<< 5AAA   	r5   r   c                "   | j         j        t          j        t          j        t          j        fv rd}|dz   }ndx}}|rd}nd}|t          j        u rW| j         j        t          j        t          j	        t          j        t          j        t          j
        t          j        fv sJ | dS |t          j        u r| d| S |t          j        u r| d| S |t          j        u s|t          j        u rt          | d          t!          |           d S )	Na  
auto current_device = guard_.current_device();
if (C10_UNLIKELY(current_device.has_value())) {
  TORCH_INTERNAL_ASSERT(*current_device == options.device(),
    "structured kernels don't support multi-device outputs");
} else {
  guard_.reset_device(options.device());
}
r   r   z
auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options);
if (C10_UNLIKELY(maybe_proxy.has_value())) {
    proxy_outputs_[output_idx] = std::move(maybe_proxy).value();
}
z<
outputs_[output_idx] = create_out(sizes, strides, options);zS
const auto& out = outputs_[output_idx].get();
check_inplace(out, sizes, options);
zY
const auto& out = outputs_[output_idx].get();
resize_out(out, sizes, strides, options);
1 structured operators are currently not supported)r$   r+   r   r/   r0   r:   r   r   r-   r,   r1   r   r   mutablescratchr   r    )rn   r   r   maybe_set_guardmaybe_set_guard_linecreate_proxys         r3   r  z7StructuredRegisterDispatchKey.gen_class_set_output_bodyd  sz   *O>/
 
 

O $3T#9  577 ? 	LL L
%%%%2  B7     - ? ? ? ?*$$$,      *.  ,      *$$$Z-?(?(? GGG   OOOOOr5   
class_namer   intc                   |t           j        u rdS |t           j        u r| dS |t           j        u rcd                    d t          |          D                       }d                    d t          |          D                       }| d| d| dS |t           j        u s|t           j        u rt          | d	          t          |           d S )
Nr   z,(Tensor& self) : outputs_{std::ref(self)} {}r   c              3      K   | ]	}d | V  
dS )zTensor& outNrL   r   r   s     r3   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s+       K Kq!2q!2!2 K K K K K Kr5   c              3  "   K   | ]
}d | dV  dS )zstd::ref(outr   NrL   r  s     r3   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s.       M M!4!4!4!4 M M M M M Mr5   r   z) : outputs_{ z } {}r  )
r   r   r   r   r   ranger  r  r   r    )rn   r   r  r   out_argsout_refss         r3   gen_class_ctorz,StructuredRegisterDispatchKey.gen_class_ctor  s    
%%%2*$$$ RRRR*.  yy K KE'NN K K KKKHyy M MeGnn M M MMMH NN8NNHNNNN*$$$Z-?(?(? GGG   OOOOOr5   re   r   c                  |t           j        u rd}d}d}nr|t           j        u r"d}d}dt          |j        j                   d}nB|t           j        u r"d}d}dt          |j        j                   d}nt          d|           | j        j	        t          j        k    r| j        rd	}	n?d
}	n<| j        j	        t          j        k    rd}	n| j        j	        t          j        k    rd}	nd}	d}
|                     ||t          |j        j                            }d| d| dt!          j        ||
           t!          j        |                     |||          |
           dd| ddd| dt          |j        j                   dt!          j        ||
           t!          j        |	|
           df
}d                    d |D                       S )NTensorzoutputs_[output_idx]r   zstd::reference_wrapper<Tensor>zaproxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get()z$std::array<::std::optional<Tensor>, z> proxy_outputs_;zUnsupported SchemaKind z4c10::hip::OptionalHIPGuardMasqueradingAsCUDA guard_;z$c10::cuda::OptionalCUDAGuard guard_;z c10::OptionalDeviceGuard guard_;r  zstruct z final : public z {zA    const Tensor& maybe_get_output(int64_t output_idx) override {z      return r   z    }z    std::array<r   z> outputs_;z};r   c              3     K   | ]}||V  	d S ri   rL   )r   lines     r3   r   z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>  s'      88$48888888r5   )r   r   r   r   r}   r   r   RuntimeErrorr$   r+   r   r/   r'   r:   r0   r  r  r  r  r   )rn   re   r   r  r   r   output_typeoutput_valueproxy_fieldguard_fieldr  class_ctor_strliness                r3   	gen_classz'StructuredRegisterDispatchKey.gen_class  s    
%%%"K1LKK*$$$:K~LgQV^ATATgggKK*.  :K~LgQV^ATATgggKK<<<===*k.>>>y ETD+AB B =KK,??<KKK,,Q
C<O<OPPCjCC,CCC~v668tBB1lTbccekllnO-L---MkMMS-@-@MMM{F335{F335
 yy88%888888r5   rV   c                    |j         rJ | j        t          j        u r| j                            |          sd S | j        j        t          j	        k    r'|j
                                        t          j        u rd S t          j        |dd          }| j                            |          }t#          |j
        d| j        j         d|d uo|                                           | j        t          j        u r=d}|                    | j                  D ]}|d|                                 d	z  }|S | j        t          j        u r6dA fd}d}|                    | j                  D ]}| ||          z  }|S | j        t          j        u r|j
                                        }g }t3                                                     }	| j        j        t          j        u rAdt9          j        | j                   d|j         }
dt9          j        | j                   }n| j        j        t          j	        u rAdt9          j        | j                   d|j         }
dt9          j        | j                   }nF| j                            | j                  }|J d|j         d|j         }
|j          d|j         }| j        j!        rtE          j#        |j
        j        j        |j
        j        j$                  }|%                    tL          '                    |j(        t3          |                                                                |t          j)        u r|%                    |
 d           n~|t          j*        u r|%                    |
 d           nW|t          j        u rId+                    d |j
        j        j        D                       }|%                    |
 d| d           d+                    d tY          |	t[          j.        | j                  d          D                       }| j        j        j/        r|%                    d| d           g | j        j        j/        j0        1                                | j        j        j/        j2        }|D ]L}|D ]G}|	%                    tg          d|j         t[          j4        ||j                                       HM|%                    d            n|%                    d!| d           t[          j5        | j                  }tm          |          D ]\  }}to          tq          tr                              |j:        j;        k    sJ |t          j        u rd"| d#}nd$| d%}|	%                    tg          |ty          |j:        j        t{          tq          tr                                                             | j        j        t          j	        k    rt          j        | j        j        d|j>                  }|?                                }|                                }d+                    d& tY          |	|                                d          D                       }|%                    d'| d(| d           ny| j        j        t          j        k    r_d+                    d) tY          |	t[          j@        | j                  d          D                       }|%                    d*| d           |t          j        u s|t          j*        u rHt          t          |j
        jC                            D ]!}|%                    d+| d,| d-| d.           "|t          j)        u rjt          |j
        jC                  d/k    rd0}nd+                    d1 t          t          |j
        jC                            D                       }d2| d#}n|t          j*        u rd3}n||t          j        u rnt          |j
        jC                  d/k    r|j
        j        j        d4         j        }n4d+                    d5 |j
        j        j        D                       }d6| d#}|%                    d7| d8           d9+                    |          }| D                    |||
|| j        j        jE        d u:           d; F                                 d<| d=S | j        t          j        u r%d>|j
        j         d?                                  d@S t          | j                   d S )BNFr   ry   rF   rz   r   r   r   r   r   r   r(   r8   c                   d|                                   d                                 dd                    d t          |                                                                           D                        dS )Nr   r   r   r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>$  r   r5   r   r   r   s    r3   r   z<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defn!  s     

 YY__y9J9J9L9Lcmmoo/^/^_____   r5   structured__meta_zat::meta::structured__default_backend_z::structured_z op;z
 op(self);r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>W  s$      (N(NA(N(N(N(N(N(Nr5   z op(r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>\  s8       # # # # # # # #r5   r   zauto precompute = op.meta(zprecompute.)binds)r   rY   z(void)precompute;zop.meta(zop.maybe_get_output(r   zop.outputs_[]c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s8       & & F& & & & & &r5   zat::r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s8       ' ' F' ' ' ' ' 'r5   zop.impl(zif (op.proxy_outputs_[z].has_value()) op.outputs_[z!].get().copy_(*op.proxy_outputs_[z]);r   zstd::move(op.outputs_[0])c              3  "   K   | ]
}d | dV  dS )zstd::move(op.outputs_[z])NrL   r  s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  sA       & & 7666& & & & & &r5   zstd::make_tuple(rn   r   c              3  $   K   | ]}|j         V  d S ri   r   r   s     r3   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s$      $J$JQV$J$J$J$J$J$Jr5   zstd::forward_as_tuple(zreturn ;r   )r  r   r   z

z {
r  r   z", TORCH_FN(r   r   )Hr   rS   r"   r   rT   r   r$   r+   r   r:   r}   r   r   r   r   r   r   r   supports_symintr   r   rU   r   r   r   rs   r   r-   metara   rm   r   r   r   r   r   r   r.   rR   rd   rb   r   r   r   r   rq   meta_argumentsprecomputedreplacevaluesaddr   argument_typeout_argumentsr   r
   r   r   nctyperY   r   r   manual_cpp_bindingmost_faithful_signatureimpl_argumentsr  r   r   r(  structured_inheritsr   r    )!rn   re   r   kernr   r   r   r   sig_bodycontextr  r   r   r   out_args_str
meta_exprsprecomputed_valuesprecomputed_elemsrc   r  r   r   r   out_sig_groupout_sigapi_name	out_exprs
impl_exprsret_exprmovedrefssig_body_strr   s!                                   @r3   r   z%StructuredRegisterDispatchKey.gen_one  sK
   //// K6...M==a@@ / 4 +AB B// 4 *>ee
 
 

 !,,Q//F@d0=@@@t#>(<(<(>(>
 
 
 ;&777F(334;3GG ; ;:w||~~::::M[F888      F(334;3GG 1 1--000M[F777A H -1,A,AG !.+2BBBL49TV+<+<LLAFLL
Jty7H7HJJ"/EF F X49TV+<+<WWqvWW
Jty7H7HJJ-88@@+++E8?EEQVEE
"*"8XXxXX!. $-OF$(!&*:*J% %! '88->(?(?    J))): 3 3 34444j(((: 9 9 9::::jn$$#yy(N(N9I9M(N(N(NNN: C C< C C CDDD  # #"Z6tv>>u  # # #  J vz% ;  KZ K K KLLL
&VZ+3::<<&FJ*.&" *<  %0   %=38%=%=%/%=c%R%R%R       34444 9: 9 9 9::: "/77H'11  
7$Yw%7%788GN<OOOOO
&&6!666DD.!...D! (#N/Yw=O=O1P1P   
 
 
 
 "/EF F !2 FFJuq?S! ! ! (??AA"<<>> II & &&w0A0A0C0CERRR& & &  	  ?x ? ?) ? ? ?@@@@#0K4DDD!YY ' '&!:46!B!B5  ' ' '  
  9: 9 9 9::: JN""a:+=&=&=s16>2233  AOOyyyqyystyyy    J)))qv~&&!++:HH II & &!&s16>':':!;!;& & &  E  ;%:::HHj(((!jn$$qv~&&!++ v/3A6;HH99$J$JQV5E5I$J$J$JJJD????HOO1h11122299X..L
  1vz-T9	           [F///FafkFFsxxzzFFFF%%%4r5   N)r   r   r   r8   r   r&   r(   r8   )r   r   r   r&   r(   r8   )r   r   r  r8   r   r  r(   r8   )re   r   r   r   r  r8   r   r8   r   r&   r(   r8   )re   r   r(   rV   )
r   r   r   r   r  r  r  r(  r   r   rL   r5   r3   r   r   C  s            :7 7 7 7v   "79 79 79 79r !C C C ! C C Cr5   r   )r$   r   r%   r&   r'   r&   r(   r)   )r$   r   r(   r6   )r$   r   r(   r)   )<
__future__r   r   r  dataclassesr   typingr   r   torchgen.api.cppapir   torchgen.api.metar9  torchgen.api.structuredrq   torchgen.api.translater   torchgen.api.typesr   r	   r
   r   r   r   r   r   r   r   r   r   torchgen.contextr   r   torchgen.modelr   r   r   r   r   r   r   r   r   r   torchgen.utilsr    r!   r"   !torchgen.selective_build.selectorr#   r4   r@   rD   rG   rJ   rM   rO   rR   r   rL   r5   r3   <module>rc     sF   " " " " " "      ! ! ! ! ! ! ) ) ) ) ) ) ) )                            , , , , , , , , , , , , , , ,                            R Q Q Q Q Q Q Q                        : 9 9 9 9 9 9 9 9 9  CBBBBBB! ! ! !H* * * *8   .   $   <   .   : $O* O* O* O* O* O* O* O*r
 $i i i i i$7 i i i i ir5   