
    9j                       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
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/m0Z0m1Z1 erd dl2m3Z3 	 	 	 	 	 	 	 	 ddZ4	 	 	 	 ddZ5ddZ6ddZ7ddZ8ddZ9ddZ: ed       G d d             Z; ed       G d de;             Z<y)    )annotationsN)	dataclass)LiteralTYPE_CHECKING)assert_never)	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)mapMaybeTarget)SelectiveBuilderc                   |rdg}ndg}| j                   t        j                  t        j                  fv r|j	                  d       n| j                   t        j
                  k(  r&|r|j	                  d       n|j	                  d       n| j                   t        j                  k(  r|j	                  d       ny| j                   t        j                  k(  r|j	                  d       nJ| j                   t        j                  k(  r|j	                  d       n|r|g d	z  }n|j	                  d
       |j	                  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/native/mtia/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MTIA)backend_indexper_operator_headersrocmheaderss       c/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torchgen/dest/register_dispatch_key.pygen_registration_headersr2   /   s   
 <=67!!koo{7G7G%HH67		#	#{'7'7	7NN>?NN?@		#	#{	6:;		#	#{	6:;		#	#{'7'7	7BC	 
 	
 	45NN34N    c                   d }d }| j                   t        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  fv r1t        | j                         j                         }d| }d| }||fS | 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)   r*   r+   r,   strlower&CompositeExplicitAutogradNonFunctionalQuantizedCPUQuantizedCUDA)r-   
empty_implempty_strided_impldispatchs       r1   gen_empty_impl_namesr=   U   s     J!!&  }11288:)(4
9(D ))) 
	#	#::  !!	( 
 !
0)))r3   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       r1   gen_create_out_helperrA   r   st    !![%5%553!%9-%H"J"	 \- 1 !!2=/ B	
 
r3   c                4    t        |       \  }}|g S 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      r1   gen_maybe_create_proxy_helperrD      sE    0?A % 	   	
r3   c                F    | 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   r7   r-   s    r1   gen_resize_out_helperrG      s,    !![%W%WW 		 r3   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");
}
 rF   s    r1   gen_check_inplace_helperrJ      s    	 r3   c                d    dgt        |       t        |       t        |       t        |       dS )Nz?C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function")zC10_DIAGNOSTIC_POP())rA   rG   rJ   rD   rF   s    r1   gen_registration_helpersrL      sS    I	}	- 
}	- 
"-	0	
 
'}	5 	 r3   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y)RegisterDispatchKeyr   r-   zvLiteral[Target.ANONYMOUS_DEFINITION, Target.NAMESPACED_DEFINITION, Target.NAMESPACED_DECLARATION, Target.REGISTRATION]targetr#   selectorboolr/   symint
str | Noneclass_method_nameskip_dispatcher_op_registrationc           	         | t         j                  k(  ryd}|dz  }|D ]@  }|j                  j                         s|d|j                   d| d|j                   dz  }B |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   NoChecktypeis_tensor_likename)rZ   argsmethod_namedevice_checkargs        r1   gen_device_checkz$RegisterDispatchKey.gen_device_check  s     ?***+NTT 	jCxx&&( %<<?HH:SUYZ]ZbZbYccf!j j	j
 r3   c                    t        |t              rF|j                  r j                        S t	        t         fdj                                     S t        |t              r j                  |      }|g S |gS t        |       y )Nc                (    j                  |       S Ngen_unstructuredfgselfs    r1   <lambda>z.RegisterDispatchKey.__call__.<locals>.<lambda>*  s    t'<'<Q'B r3   )

isinstancer   
structuredgen_structuredlistr!   	functionsr   rf   r   )rj   rh   rri   s   `  @r1   __call__zRegisterDispatchKey.__call__   s    a-.&'A ||**1--BAKKMR  >*%%a(A2++Or3   c                    t        j                  |j                  d| j                  j                   d|j                  j
                  j                   d| j                        S )Nwrapper_rC   prefixrS   )r   from_schemafuncr-   r%   r\   overload_namerS   )rj   rh   s     r1   wrapper_kernel_sigz&RegisterDispatchKey.wrapper_kernel_sig2  sT     #..FFd00==>a@Y@Y?ZZ[\;;
 	
r3   c                   |y |j                   j                         }|t        j                  u rdn |t        j                  u rdnt        d      | j                  |      }|j                         }| dt        j                  |      }t        |      dkD  rXdj                  fdt        |      D              }|j                         j                          dd	j                  |       d
}nt        |      dk(  r|d   }	 d d	|	 d}|	}nt        |j                   j                  j                        dk7  r5t        dt        |j                   j                  j                               d}|j                   j                  j                  d   }
|
j                   j#                         rd d d d|
j                   d	}n d d	|
j                   d}| j                  |j$                        }|j                         }|j'                  |       d d|j                          dd	j                  d t)        |j                         |j                               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  yw)z
(std::get<z>(z), );NrI   ).0iret_namecopy_opfunc_ress      r1   	<genexpr>z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>O  s6      "Ax ):aS8*CzD"s   (, )r   r   z%Expected exactly 1 out argument, got  z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }r\   z
 {
  auto z = c              3  4   K   | ]  }|j                     y wrd   exprr   es     r1   r   z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>l  s     6~!qvv6~   z);
  

  return ;
}
)rx   kindr   inplaceoutAssertionErrorrz   r\   cppreturn_nameslenjoin	enumeratereturns_typecpp_type	argumentsrZ   is_list_like
functionaldefnr   )rj   rh   ri   ksigr\   r   updatesreturnsr   out_argfunctional_sigwrapper_namer   r   s                @@r1   gen_out_inplace_wrapperz+RegisterDispatchKey.gen_out_inplace_wrapper<  s~    9FFKKM
"""&G*.. 1G !TUU%%a(xxzV4=''*|q kk "#,\#:" G ))+4467q<9P8QQRSG!##AH 	8*Bxj;GG166##''(A-$;C@P@P@T@T<U;VW  Gff&&**1-G||((*%J '			8*E',, 0

 %IQxj7<<.C00>xxz |  z^((*+1TYY6~yQTQ^Q^Q`bpbzbzb|G}6~-~, @
) 

 	 	r3   c           
          j                   j                        } j                   j                  t        j                  k(  r0 j                   j                  j                        rt        d       j                   j                  t        j                  k(  r0 j                   j                  j                        r@t        d      ||j                  s't        t         fdj                                     S t         j                    j                   j                   j                    j"                   j$                   j&                        }t        t        |j(                  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                (    j                  |       S rd   re   rg   s    r1   rk   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>  s    4+@+@A+F r3   )r-   
get_kernelr%   r   r'   
has_kernelr   r   r7   rm   ro   r!   rp   StructuredRegisterDispatchKeyrP   rQ   r/   rS   rU   rV   gen_one)rj   ri   metadatastructured_gens   ``  r1   rn   z"RegisterDispatchKey.gen_structuredr  s8   %%003**k.>.>>!!,,QUU3$N 
 ++AAB !!,,QUU3$Y  X%8%8!FVWW6KKMMIIKK""00	
 H^33Q[[]CDDr3   Nc                   t        |      5  d}d}| j                  j                  |      s| j                  j                  t        j
                  k(  r[|j                  j                         t        j                  u r1|j                  s%t        |j                  j                        dk(  rd}n<| j                  j                  s|t        ||| j                        rd}n
	 d d d        y |j                  r
	 d d d        y | j                   t"        j$                  u r%| j&                  j)                  |      s
	 d d d        y | j+                  |      j-                         }j/                         j1                         }j3                         }dj5                  d |D              }t7        j8                  |dd      }	| j                   t"        j:                  u rEd}
|	j=                  | j>                        D ]  }|
d	|jA                          d
z  }
 |
cd d d        S | j                   t"        jB                  u r?d(fd}d}
|	j=                  | j>                        D ]  }|
 ||      z  }
 |
cd d d        S | j                   t"        jD                  u rU|rz|j                  j2                  jF                  tI        d      |j                  j2                  jF                  jJ                  j,                  }d| d| d| d| d| dcd d d        S |r| jM                  ||      cd d d        S | j                  jO                  |      }|
	 d d d        y | jP                  |jR                   d|jT                   }n(|jR                   d| jP                   d|jT                   }tW        || j                        }dj5                  d tY        j3                         |j3                         d      D              }d}| j                  jZ                  r|t]        j^                  |j                  j2                  j`                  |j                  j2                  jb                        }td        jg                  |jh                  tk        |      |      }d}|jZ                  r+| j                  jZ                  rtm        d |j                  j2                  jn                  D              }|r'd}tq        | j                  j                        rd| }n|j                  j2                  jF                  +|j                  j2                  jF                  jJ                  gng }t]        j^                  ||j                  j2                  j`                  |j                  j2                  jb                        }ts        d |D        d       }|d| d}d| d| d| d| d | d!| d| d"cd d d        S | j                   t"        j$                  u rN|j                  s| jt                  r
	 d d d        y d#| d$}d%|j                  j,                   d&| d'cd d d        S tw        | j                          	 d d d        y # 1 sw Y   y xY w))NFr}   Tr   c              3  <   K   | ]  }|j                           y wrd   )r   r   as     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s      8a 8   methodfallback_bindingr   rS   
TORCH_API ;
c                    d| j                          dj                          ddj                  d t        | j	                         j	                               D               dS )N

 {
return r   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>       _!qvv_r   );
}
r   r\   r   r   r   cpp_sigr   s    r1   generate_defnz;RegisterDispatchKey.gen_unstructured.<locals>.generate_defn  s`       
|1TYY_y9J9J9Lcmmo/^__` a r3   z1Expected self_arg to be non-None for inplace_metar    r   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return r   z::c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s      + FF+r   r   rX   z// DeviceGuard omittedc              3  <   K   | ]  }t        |t                y wrd   )rl   r    r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>  s       - #1&<=-r   z=
  const DeviceGuard device_guard(device_or_default(device));z7globalContext().lazyInitDevice(c10::DeviceType::CUDA);
c              3  j   K   | ]+  }|j                   j                         r|j                    - y wrd   )rZ   r[   r\   r   s     r1   r   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>%  s0      $%#$66#8#8#: $%66(s   13z1const OptionalDeviceGuard device_guard(device_of());znamespace {

z) {
  z

  r   z);
}

} // anonymous namespace
z	TORCH_FN(r   m.impl("z",
z);
r   r   returnr5   )<r   r-   r   r%   r   r'   rx   r   r   r   has_composite_kernelr   r   use_out_as_primaryr   manual_kernel_registrationrP   r"   REGISTRATIONrQ   is_native_function_selectedrz   r\   r   r   r   r   r   from_native_functionNAMESPACED_DECLARATION
signaturesrS   declNAMESPACED_DEFINITIONANONYMOUS_DEFINITIONself_argr   argumentr   r   rU   cpp_namespacekernelr   r   device_guard	itertoolschainr   flat_positionalrO   ra   r_   ro   anynon_outr   nextrV   r   )rj   rh   ri   inplace_metagets_out_inplace_wrapperr\   r   r]   args_strcpp_sig_groupresultr   r   self_arg_namer   	impl_name
kernel_sigargs_exprs_strr_   device_check_argsr   has_tensor_optionsr   candidate_args	device_ofpayloadr   s                             @r1   rf   z$RegisterDispatchKey.gen_unstructured  sR    %Q' o	* L',$%%003&&33{7G7GG););; .. '1,#'L**==:1aASAST 04,/o	* o	*0 ++3o	* o	*8 v222AA!D?o	* o	*B ))!,C88:D++-668L==?Dyy 84 88H .BB%%M
 {{f;;;,77t{{7K ?G
7<<>*:#>>F?eo	* o	*f  < << ,77t{{7K 5GmG44F5o	* o	*B  ; ;;vv''008,O  %&FF$4$4$=$=$F$F$K$KM avQxj !,o .

 	Uo	* o	*f ,771=io	* o	*l  --88;#qo	* o	*r ))1#+#9#9":"X__<M NI#+#9#9":"T=S=S<TTVW_WfWfVg hI-a1C1CD
!% +&)=)=)?+ "  8%%22(1((,,aff.>.>.N.N)% $7#G#G->(?$L  8>>d&8&8&E&E), -!"!1!1!9!9- *& *(@ 00B0B0O0OP-efres+tL  !vv//88D VV--66??@!# !
 *3$FF,,00FF,,<<* %))7
 !%	 %0-^_h^iil+mL avQxj !. . 

An% &wo	* o	*P  3 33//43W3WUo	* o	*X !*$q1G%affkk]$witD[o	* o	*^ T[[)_o	* o	* o	*sR   CY8+Y88Y8CY8"AY8=BY8Y83Y8JY8/5Y8-"Y8Y88Z)rZ   r   r]   zlist[Argument]r^   r5   r   r5   )rh   z%NativeFunctionsGroup | NativeFunctionr   	list[str])rh   r   r   z%NativeSignature | DispatcherSignature)rh   r   ri   zNativeFunctionsGroup | Noner   rT   )ri   r   r   r   rd   )__name__
__module____qualname____annotations__staticmethodra   r   rr   rz   r   rn   rf   rI   r3   r1   rO   rO      s       J
 L "! &*)%3BE	  ! !"

	.
44$?4	4lE@ CGr*r*$?r*	r*r3   rO   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	y)r   r   ri   c                ^     |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   c           	         d|  dt        j                  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)r\   maybe_create_proxyr   rj   set_output_supers     r1   gen_set_output_functionz]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionY  s\      
//3EFO P Q 
!6* + , r3   r   stridedT)r  raw_stridedF)r\   r5   r  rR   r   r5   rI   )rj   r   parent_classgenerate_superr  r  s   ``   @r1   gen_class_set_output_functionsz<StructuredRegisterDispatchKey.gen_class_set_output_functionsQ  sU     "./tu!	 t< = >5A B C 	r3   c                &   | j                   j                  t        j                  t        j                  t        j
                  t        j                  fv rd}|dz   }ndx}}|rd}nd}|t        j                  u r| j                   j                  t        j                  t        j                  t        j                  t        j                  t        j
                  t        j                  t        j                  fvr#t        d| j                   j                   d      | 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#        |       y )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Unexpected dispatch key z for functional schemaz<
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)   r*   r+   r7   r   r   r'   r&   r,   r   r   r   mutablescratchr   )rj   r   r  maybe_set_guardmaybe_set_guard_linecreate_proxys         r1   r  z7StructuredRegisterDispatchKey.gen_class_set_output_bodyn  s   **OOOO>>	/
 
O $3T#9 577 ?L L
%%%!!..      BB7  %.t/A/A/N/N.O P, ,  -- .< ? ?*$$$,- .   *.. ,- .   *$$$Z-?-?(? #FG  Or3   c                   |t         j                  u ry|t         j                  u r| dS |t         j                  u rMdj	                  d t        |      D              }dj	                  d t        |      D              }| d| d| dS |t         j                  u s|t         j                  u rt        | d	      t        |       y )
Nr   z,(Tensor& self) : outputs_{std::ref(self)} {}r   c              3  &   K   | ]	  }d |   yw)zTensor& outNrI   r   r   s     r1   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s      Kq;qc!2 Ks   c              3  (   K   | ]
  }d | d  yw)zstd::ref(outr   NrI   r  s     r1   r   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>  s      M<s!!4 M   r   z) : outputs_{ z } {}r  )
r   r   r   r   r   ranger  r  r   r   )rj   r   
class_namer   out_argsout_refss         r1   gen_class_ctorz,StructuredRegisterDispatchKey.gen_class_ctor  s    
%%%*$$$ \!QRR*.. yy KE'N KKHyy MeGn MMH \8*OH:XNN*$$$Z-?-?(? #FG  Or3   c                  |t         j                  u rd}d}d}n|t         j                  u r(d}d}dt        |j                  j
                         d}nH|t         j                  u r(d}d}dt        |j                  j
                         d}nt        d|       | j                  j                  t        j                  k(  rd	}	n| j                  j                  t        j                  k(  rd
}	n| j                  j                  t        j                  k(  rd
}	nV| j                  j                  t        j                  k(  rd
}	n,| j                  j                  t        j                  k(  rd
}	nd}	d}
| j!                  ||t        |j                  j
                              }d| d| dt#        j$                  ||
       t#        j$                  | j'                  |||      |
       dd| ddd| dt        |j                  j
                         dt#        j$                  ||
       t#        j$                  |	|
       df
}dj)                  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 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   | ]	  }|s|  y wrd   rI   )r   lines     r1   r   z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>  s     8$48s   )r   r   r   r   rx   r   r   RuntimeErrorr-   r%   r   r)   r7   r*   r+   r,   r  r   r   r	  r   )rj   rh   r   r  r  r  output_typeoutput_valueproxy_fieldguard_fieldr   class_ctor_strliness                r1   	gen_classz'StructuredRegisterDispatchKey.gen_class  s    
%%%"K1LK*$$$:K~L@QVV^^AT@UUfgK*.. :K~L@QVV^^AT@UUfgK!8<==**k.>.>>@K++AAB =K,,?<K,,?<K,,0@0@@<KK,,Q
C<OPj\!1,sC~v67tBB1lTbceklmOL>-k]"S-@,AM{F34{F34
 yy8%888r3   c                   |j                   r#t        d|j                  j                   d      | j                  t
        j                  u r| j                  j                  |      sy | j                  j                  t        j                  k(  r+|j                  j                         t        j                  u ry t!        j"                  |dd      }| j                  j%                  |      }t'        |j                  d| j                  j                   d|d uxr |j)                               | j                  t
        j*                  u r<d}|j-                  | j.                  	      D ]  }|d
|j1                          dz  } |S | j                  t
        j2                  u r6d@fd}d}|j-                  | j.                  	      D ]  }| ||      z  } |S | j                  t
        j4                  u r{|j                  j                         }g }t7        j9                               }	| j                  j                  t        j:                  u rSdt=        j                  | j>                         d|j                   }
dt=        j                  | j>                         }n| j                  j                  t        j                  u rRdt=        j                  | j>                         d|j                   }
dt=        j                  | j>                         }n| j                  j%                  | j>                        }|6t        d| j>                  j@                  j                  j                         d|jB                   d|j                   }
|jD                   d|jB                   }| j                  jF                  rtI        jJ                  |j                  j8                  j                  |j                  j8                  jL                        }|jO                  tP        jS                  |jT                  t7        |      j                                      |t        j@                  u r|jO                  |
 d       n|t        jV                  u r|jO                  |
 d       n_|t        j                  u rMdjY                  d |j                  j8                  j                  D              }|jO                  |
 d| d       djY                  d t[        |	t]        j^                  | j>                        d      D              }| j>                  j                  j`                  r|jO                  d| d       g | j>                  j                  j`                  jb                  je                         | j>                  j                  j`                  jf                  }|D ]  }|	ji                  d |D                |jO                  d       n|jO                  d| d       t]        jj                  | j>                        }tm        |      D ]  \  }}to        tq        tr                    |jt                  jv                  k7  r"t        d|jt                  jv                         |t        j                  u rd | d!}nd"| d#}|	jO                  ty        |t{        |jt                  j                  t}        tq        tr                          $              | j                  j                  t        j                  k(  rt!        j"                  | j>                  j                  d|j~                        }|j                         }|j                         }djY                  d% t[        |	|j9                         d      D              }|jO                  d&| d'| d       n}| j                  j                  t        j:                  k7  rVdjY                  d( t[        |	t]        j                  | j>                        d      D              }|jO                  d)| d       |t        j                  u s|t        jV                  u rHt        t        |j                  j                              D ]  }|jO                  d*| d+| d,| d-        |t        j@                  u rjt        |j                  j                        d.k(  rd/}ndjY                  d0 t        t        |j                  j                              D              }d1| d!}n|t        jV                  u rd2}n|t        j                  u rt        |j                  j                        d.k(  r.|j                  j8                  j                  d3   j                  }n<djY                  d4 |j                  j8                  j                  D              }d5| d!}|jO                  d6 d7       d8jY                  |      }| j                  |||
|| j>                  j                  j                  d u9       d:j                          d;| d<S | j                  t
        j                  u r+d=|j                  j                   d>j                          d?S t        | j                         y )ANz	Function z$ has manual_kernel_registration=TrueFr   rt   rC   ru   r   r   r   r   c                    d| j                          dj                          ddj                  d t        | j	                         j	                               D               dS )Nr   r   r   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>8  r   r   r   r   r   s    r1   r   z<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defn5  s`      
|1TYY_y9J9J9Lcmmo/^__` a r3   structured__meta_zat::meta::structured__default_backend_zNo kernel metadata found for z::structured_z op;z
 op(self);r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>n  s     (NA(Nr   z op(r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>s  s      # #r   r   zauto precompute = op.meta(c              3     K   | ]=  }t        d |j                   t        j                  ||j                               ? yw)zprecompute.)bindsr   rZ   N)r   r\   rm   argument_type)r   r`   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  sF      #
  	 #.sxxj!9!+!9!9#SXX!N #s   AAz(void)precompute;zop.meta(zCExpected out_arg type to be ConstRefCType(BaseCType(tensorT)), got zop.maybe_get_output(r   zop.outputs_[]r1  c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s      & FF&r   zat::r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s      ' FF'r   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  yw)zstd::move(op.outputs_[z])NrI   r  s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s!      & 126&r  zstd::make_tuple(rj   r   c              3  4   K   | ]  }|j                     y wrd   r   r   s     r1   r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>  s     $JQVV$Jr   zstd::forward_as_tuple(zreturn ;r   )r  r  r  z

z {
r   r   z", TORCH_FN(r   r   )Ir   r   rx   r\   rP   r"   r   rQ   r   r-   r%   r   r7   r   r   r   r   r   r   r   supports_symintr   r   rS   r   r   r   ro   r   r'   metari   r   r   r   r   r   r   r   r(   rO   ra   r_   r   r   r   rm   meta_argumentsprecomputedreplacevaluesaddextendout_argumentsr   r   r	   r   nctyperZ   r   r   r   manual_cpp_bindingmost_faithful_signatureimpl_argumentsr  r   r   r&  structured_inheritsr   r   ) rj   rh   r   kernr   r   r   r   sig_bodycontextr  r  r   r   out_args_str
meta_exprsprecomputed_valuesprecomputed_elemsr  r   r   r   out_sig_groupout_sigapi_name	out_exprs
impl_exprsret_exprmovedrefssig_body_strr   s                                   @r1   r   z%StructuredRegisterDispatchKey.gen_one  s/	   '' AFFKK=(LM 
 KK6...MM==a@ ++AAB/  *>>ee

 !!,,Q/FFd00==>a@t#>(<(<(>
 ;;&777F(334;;3G ;Jw||~&6c::;M[[F888 F(334;;3G 1-001M[[F777A H -1,AG !!..+2B2BB*499TVV+<*=VAFF8L
!6tyy7H6IJ""//EEF  +499TVV+<*==NqvvhW
!6tyy7H6IJ--88@#(78I8I8N8N8S8S7TU   +8??*;1QVVHE
"*"8"8!9xFWX!!..$-OOFF$$((!&&*:*:*J*J%! '88->(? J))):,d 34j(((:,j 9:jnn$#yy(N9I9I9M9M(NN:,d<. CD  #"Z66tvv>u# J vvzz%% "<ZL KL
&VVZZ++33::<&FFJJ**..&" *< %NN #
 $5#   34(:,b 9: "//7H'1 
7 7!348K8KK(&~~2235 
 
&1!A6D)!A.D! (#NN//Yw=O1P
6 ""//EEF !2 F FFFJJuq?S?S! (??A"<<> II &&w0A0A0CER& 	 $xj)B ?@##00K4D4DD!YY '&!:!:466!B5' 
 (:,b 9: JNN"a:+=+=&=s166>>23 AOO03NqcQrstruuxy J)))qvv~~&!+:H II &!&s166>>':!;& E "2%:Hj(((!jnn$qvv~~&!+ vv//33A6;;H99$JQVV5E5E5I5I$JJD!7vQ?HOOghZq1299X.L )!-#'66::#A#A#M       [[F///affkk],sxxzl#FF%r3   N)r   r   r  r5   r  rR   r   r5   )r   r   r  rR   r   r5   )r   r   r  r5   r   intr   r5   )rh   r   r   r   r  r5   r  r5   r  rR   r   r5   )rh   r   r   rT   )
r   r   r   r   r	  r  r  r&  r   r   rI   r3   r1   r   r   M  s    +.@D	:=B"8989 89
 89 89 89 
89t !P !Pr3   r   )r-   r   r.   rR   r/   rR   r   r   )r-   r   r   ztuple[str | None, str | None])r-   r   r   r   )=
__future__r   r   r   dataclassesr   typingr   r   typing_extensionsr   torchgen.api.cppapir   torchgen.api.metar:  torchgen.api.structuredrm   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"   !torchgen.selective_build.selectorr#   r2   r=   rA   rD   rG   rJ   rL   rO   r   rI   r3   r1   <module>rf     s    "   ! ) *       , , ,    R   , B### # 	#L**"*:.$<.: $U* U* U*~
 $}$7 } }r3   