
    Vhj                   
   d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl	Z	d dl
Z
d dlZd dlZd dlmZ d dlmZ d dlmZmZmZmZmZmZmZmZ d dlmZmZ d dlmZ d dlZd dlmc mZ  d dlm!Z!m"Z"m#Z#m$Z$ d d	l%m&Z&m'Z' d d
l(m)Z) d dl*m+Z+ d dl,m-Z- d dl.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z= d dl>m?Z?m@Z@ d dlAmBZB d dlCmDZD d dlEmFZFmGZG d dlHmIZImJZJmKZKmLZLmMZMmNZN d dlOmPZP d dlQmRZR ddlSmTZTmUZUmVZV er&d dlWmXZXmYZYmZZZm[Z[ d dl\m]Z] d dl^m_Z_ d dl`maZa d d lbmcZcmdZd  ej                  ef      Zg	 ej                  j                  efd!      Zj G d# d$      Zn en       ZoepZqej>                  j                  Zs ed%      Ztej                  j                  j                  ZwdZxd ay G d& d'      Zze G d( d)e{             Z|e G d* d+e{             Z}e G d, d-e{             Z~e G d. d/e{             Ze G d0 d1e{             Z G d2 d3e	j                        Z e       Zdhd4Zej
                  did5       Z	 	 	 	 	 	 djd6Zdkd7Zdld8Z ej                  d      dmd9       Z ej                  d      dnd:       Zdod;Zdpd<Z G d= d>      Z ej                  d      dqd?       Zej
                  	 	 	 	 drdA       ZdndBZ G dC dD      Z G dE dF      Z G dG dHe$      Zee?dIdJf   ZeBe G dK dL                    ZdsdMZeBe G dN dO                    ZeB edPQ       G dR dS                    ZeB edPQ       G dT dU                    ZeB edPQ       G dV dWe                    ZeB edPQ       G dX dY                    Z G dZ d@eG      ZeZ	 	 	 	 	 	 	 	 	 	 	 	 dtd[Z G d\ d]e=      Zdud^Zdvd_Zdwd`Zej                  jN                  jP                  jR                  eej                  j                  jT                  jR                  da ej                  j                  jV                  jR                  db ej                  j                  jX                  jR                  dc iZ eej                  j                  j\                  jR                  ej                  j                  j^                  jR                  ej                  j                  j`                  jR                        Zd ddlmZmZmZmZmZmZmZmZ ejv                  dxde       Z	 	 	 	 	 	 	 	 dydfZ	 	 	 	 	 	 	 	 dzdgZy# ek$ rZld" emel      v rd dlZjnelY dZl[ldZl[lww xY w){    )annotationsN)defaultdict)	dataclass)AnyCallablecastLiteralOptionalTYPE_CHECKINGTypeVarUnion)Self	TypeGuard)ReferenceType)SymBoolSymFloatSymIntTensor)is_functorch_wrapped_tensoris_legacy_batchedtensor)FakeScriptObject)dtrace_structured)suggest_memory_format)	assert_eqassert_metadata_eqis_sparse_anyis_sparse_compressedMetaConverter)render_call)immutable_dict)normalize_function)StorageWeakRef)TorchFunctionMode)IntLikeTypepy_sym_types)dataclass_slots)no_dispatch)is_traceable_wrapper_subclassTorchDispatchMode)KeyPathkeystrPyTreetree_map	tree_map_TreeSpec)count)CapturedTraceback   )_CacheKeyState_PySymInputStub_SymIntOutputStub)	GeneratorIterableMappingSequence)TracebackType)Source)
OpOverload)ShapeEnvSymbolicContextnot_implementedz 'not_implemented' not registeredc                      e Zd Zy)_UnassignedN)__name__
__module____qualname__     M/home/dcms/DCMS/lib/python3.12/site-packages/torch/_subclasses/fake_tensor.pyrA   rA   K   s    rF   rA   Tc                      e Zd ZddZddZy)IncrementRecursionCountc                    t         dz  a y Nr2   RECURSION_COUNTselfs    rG   __init__z IncrementRecursionCount.__init__b       1rF   c                    t         dz  a y rL   rM   rO   s    rG   __del__zIncrementRecursionCount.__del__f   rR   rF   NreturnNone)rB   rC   rD   rQ   rT   rE   rF   rG   rJ   rJ   a   s    rF   rJ   c                      e Zd ZU ded<   y)UnsupportedFakeTensorExceptionstrreasonNrB   rC   rD   __annotations__rE   rF   rG   rY   rY   k       KrF   rY   c                      e Zd ZU ded<   y)DynamicOutputShapeExceptionr<   funcNr\   rE   rF   rG   r`   r`   p       
rF   r`   c                      e Zd ZU ded<   y)DataDependentOutputExceptionr<   ra   Nr\   rE   rF   rG   rd   rd   u   rb   rF   rd   c                      e Zd ZU ded<   y)UnsupportedOperatorExceptionr<   ra   Nr\   rE   rF   rG   rf   rf   z   rb   rF   rf   c                      e Zd ZU ded<   y)MetadataMismatchErrorrZ   r[   Nr\   rE   rF   rG   rh   rh      r^   rF   rh   c                       e Zd ZU ded<   ddZy)FakeTensorTLSOptional[bool]allow_non_fake_inputs_overridec                    d | _         y N)rl   rO   s    rG   rQ   zFakeTensorTLS.__init__   s
    .2+rF   NrU   )rB   rC   rD   r]   rQ   rE   rF   rG   rj   rj      s     %323rF   rj   c                 .    t         j                  | d      S NT)dictfromkeys)itemss    rG   ordered_setrt      s    ==%%rF   c               #  *  K   t         j                  j                  t         j                  j                  j                        } 	 |  |  t         j                  j                  |        y y # |  t         j                  j                  |        w w xY wwrn   )torch_C_unset_dispatch_mode_TorchDispatchModeKeyFAKE_set_dispatch_mode)olds    rG   unset_fake_temporarilyr}      sl     
((
'
'(F(F(K(K
LC-	?HH'', 3?HH'', s   ABA, 	#B,$BBc                   | g}|rf|j                         t              s|j                         /j                         \  }}|j	                  fdt        |      D               |rf|S )Nc              3  6   K   | ]  }t        |        y wrn   )getattr).0keycurrs     rG   	<genexpr>z$get_plain_tensors.<locals>.<genexpr>   s     G3GD#&Gs   )popr(   append__tensor_flatten__extendreversed)subclassouttodo
inner_keys_r   s        @rG   get_plain_tensorsr      sf     :D
xxz,T2JJt//1
AG(:2FGG  JrF   c                   ddl m} t        | t              ryt	        |       rht        |       j                  |       \  }}|D cg c]  }t        | |       }}t        d |D              }t        d |D              }||k(  sJ d       |S t        | |      rt        | j                        S t        | t              rht        j                  |       rSt        j                  j!                         }t        j                  j"                  j%                  | |      }	t        |	      S t        | t              r?t'        |       r4t        j                  j"                  j)                  |       }	t        |	      S yc c}w )Nr   FunctionalTensorTc              3  2   K   | ]  }t        |        y wrn   is_faker   xs     rG   r   zis_fake.<locals>.<genexpr>        =awqz=   c              3  2   K   | ]  }t        |        y wrn   r   r   s     rG   r   zis_fake.<locals>.<genexpr>   r   r   z got mixed fake and real tensors!F)#torch._subclasses.functional_tensorr   
isinstance
FakeTensorr(   typer   r   allanyr   elemr   rv   _is_functional_tensorrw   $_functionalization_reapply_views_tls
_functorch_unwrap_functional_tensorr   get_unwrapped)
r   r   attrsr   attrflattened_tensorsall_fakeany_fakereapply_views	unwrappeds
             rG   r   r      s1   D!Z $Q'7--a0q:?@$WQ-@@=+<===+<==8#G%GG#	A'	(qvv	Av	5#>#>q#AEEGHH''AA!]S	y!!	Av	#>q#AHH''55a8	y!! As   E4c           	        ddl m} t        | t              r| j                  S t        |       rR| j                         \  }}|D cg c]  }t        t        | |             }}|d   t        fd|D              sJ S t        | |      rt        | j                        S t        | t              rht        j                  |       rSt        j                  j                         }t        j                  j                   j#                  | |      }t        |      S t        | t              r?t%        |       r4t        j                  j                   j'                  |       }t        |      S y c c}w )Nr   r   c              3  &   K   | ]  }|u  
 y wrn   rE   )r   r   ms     rG   r   z&maybe_get_fake_mode.<locals>.<genexpr>   s     )a16)s   )r   r   r   r   	fake_moder(   r   maybe_get_fake_moder   r   r   r   rv   r   rw   r   r   r   r   r   )	tr   inner_tensor_namesr   t_namemodesr   r   r   s	           @rG   r   r      s*   D!Z {{$Q' ! 4 4 6ABT
8>6 23
 
 !H)5))))	A'	("166**	Av	5#>#>q#AEEGHH''AA!]S	"9--	Av	#>q#AHH''55a8	"9--
s   E*c                T    t         j                  j                  | j                        S rn   )rv   rw   _SchemaInfo_schemara   s    rG   get_schema_infor      s    88--rF   c                    ddl m} t        j                  j                  }||    j
                  j                  d      xr ||    j                  t        |      v S )Nr   decomposition_tableztorch._decomp)	torch._decompr   rv   _decompdecompositionsrC   
startswithrB   dir)ra   r   r   s      rG   torch_decomp_decompositionsr      sV    1]]11N t$//:: D
d
#
,
,N0C
CDrF   c                p    t         j                  |      }|D cg c]  }t        ||       s| c}S c c}w rn   )pytreetree_leavesr   )tytree	flat_valsr   s       rG   tree_flatten_onlyr      s/    ""4(I&?T*T2*>D???s   33c                    t        |       t        u xrk | j                  t        j                  k(  xrL | j
                  xs= | j                  xs/ t        |       xs" t        |       xs t        j                  |        S rn   )
r   r   layoutrv   strided	is_sparse	is_nestedr   r   r   r   s    rG   _is_plain_tensorr      sx    Q6 	
HH%	
 KK .{{.*1-. 'q). **1-

rF   c                      e Zd ZU e	 	 dd       Zded<   ded<   ded<   ddd	dd
ZddZddZddZ	ddZ
	 	 ddddd	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZy)FakeTensorConverterc                .    | j                   j                  S rn   )meta_convertertensor_memorO   s    rG   r   zFakeTensorConverter.tensor_memo  s     ""...rF   r   r   z)dict[StorageWeakRef, list[ReferenceType]]constant_storage_mappingboolexportF	copy_datar   c               B    t        |      | _        || _        i | _        y )N)r   )r   r   r   r   )rP   r   r   s      rG   rQ   zFakeTensorConverter.__init__  s     +i@ )+%rF   c                "   t        |t              r|j                  J t        |j                  j	                               }|| j
                  vrg | j
                  |<   | j
                  |   j                  t        j                  |             y rn   )	r   r   constantr"   _typed_storager   r   weakrefref)rP   fake_tensorweak_sts      rG   add_constant_storage_mappingz0FakeTensorConverter.add_constant_storage_mapping"  sz     +z2{7K7K7WWW !5!5!D!D!FG
 $77757D))'2%%g.55gkk+6NOrF   c                    t        |t              rJ t        |j                               }|| j                  vry | j                  |   D ]#  } |       }||j                          d |_        % | j                  |= y rn   )r   r   r"   r   r   _fix_weakrefr   )rP   tensorr   weak_tensor_reftens        rG   invalidate_constant_aliasesz/FakeTensorConverter.invalidate_constant_aliases0  s    fj111 !6!6!89$777#<<WE 	$O!#C  "#		$ ))'2rF   c                    | j                   j                  j                  j                  |      }|y | j                  j                  |      S rn   )r   	describerlookup_tensorgetr   )rP   r   tids      rG   	_get_memozFakeTensorConverter._get_memo?  sC    !!++99==a@;##C((rF   c                    | j                   j                  j                  |      }|| j                   j                  |<   y rn   )r   r   get_tensor_idr   )rP   r   vr   s       rG   set_tensor_memoz#FakeTensorConverter.set_tensor_memoE  s4    !!++99!</0'',rF   NT)sourcesymbolic_contexttracec                  |sk|si|rgt         j                  j                  j                         x}r=||j                  v r/|j                  |   }ddlm}	 t        ||	      sJ |j                  }| j                  |      }
|
|
S |j                  rt        d      t        |      t         j                  j                  u r|rJ |r|nd 	 	 	 	 	 	 dfd}| j                  ||||||      }|t         u rt        d      ddlm} d }| j&                  st)        |      r|j+                         dk(  r|j,                  j                  dk(  ru|j.                  t         j0                  t         j2                  t         j4                  t         j6                  t         j8                  fv r|t        ||      s|dd	lm}m} dd
lm} tA               5  |jC                         }d d d        tE        jF                  |      stE        jH                  |      st        ||      r|jJ                  }n ||      }|jM                  |||jN                  |      }|j.                  t         j0                  k(  r|jQ                  |||      |_)        n6|j.                  t         j8                  k(  r|jU                  |||      |_)        |r| jW                  |       |S # 1 sw Y   xY w)Nr   )StatefulSymbolicContextzquantized nyi in meta tensorsc                l    t               5  t         |        |      cd d d        S # 1 sw Y   y xY w)Nr   )r'   r   )make_meta_tdevicer   r   s     rG   mk_fake_tensorz<FakeTensorConverter.from_real_tensor.<locals>.mk_fake_tensort  s7      !M &  s   *3)	shape_envcallbackr   r   r   zmeta converter nyi)RandomValueSourcecpu)CallMethodItemSourceFloatTensorSource)
DimDynamic)r   dynamic_dimr   )hintr   )r   zCallable[[], object]r   zUnion[torch.device, str]rV   r   ),rv   _guardsTracingContexttry_gettensor_to_context%torch.fx.experimental.symbolic_shapesr   r   tensor_sourcer   is_quantizedrY   r   nn	Parameterr   NotImplementedtorch._dynamo.sourcer  r   r   dimr   dtypeint64int32int16int8float64r  r  r  r'   itemmathisnanisinfbasecreate_unspecified_symbolDYNAMICcreate_symintnode	item_memocreate_symfloatnoder   )rP   r   r   make_constantr   r   r   r   tracing_contextr   
maybe_memor   r   r  valuer  r  r  item_sourcesymbolr   s    `                  @rG   from_real_tensorz$FakeTensorConverter.from_real_tensorO  s     9"'--">">"F"F"HHH999'6'H'H'K$ &&68OPPP-;;F^^A&
!>>01PQQ7ehh((($$$%14
	-	7O		( !!#- " 
 . 01EFF: #1& U[[%++uzz5==QR"$ v'89 %TH !!::e$TZZ->f&78"(++K"6v">K"<<& * 2 2%5	 =  77ekk)$-$?$?"* %@ %CM
 WW-$-$A$A"* %B %CM
 --c2
?! !s   KK$c                    |j                   j                  dk(  sJ d|j                   j                   d       | j                  |      }||S t        |||      }| j	                  ||       |S )Nmetaz$tensor's device must be `meta`, got z instead)r   r   r   r   r   )rP   r   r   r   r'  r   s         rG   from_meta_and_devicez(FakeTensorConverter.from_meta_and_device  sv     HHMMV#	J1!((--I	J# ^^A&
!Av.Q$
rF   )rV   zweakref.WeakValueDictionary)r   r   r   r   rV   rW   )r   r   rV   rW   )r   r   rV   rW   )r   r   rV   Optional[FakeTensor])r   r   r   r   rV   rW   )FN)r   FakeTensorModer   r   r%  r   r   Optional[ShapeEnv]r   Optional[Source]r   Optional[SymbolicContext]r   r   rV   r   )r   r0  r   r   r   torch.devicerV   r   )rB   rC   rD   propertyr   r]   rQ   r   r   r   r   r+  r.  rE   rF   rG   r   r     s    /	$/ / "!GGL,1% +P3)1 $(,M $(6:M!M M 	M
 &M !M 4M M 
M`',2<H	rF   r   c                   t         j                  j                         st         j                  j                         rIt         j                  j
                  t        j                  d|       nt        j                  d|        y y )Nr2   r   )rv   cudais_availablexpuversionhipemptyzerosr7  s    rG   init_gpu_contextr?    sY     zz EII$:$:$< }}  ( KK&)Qv.	 %=rF   r0  c              #    K   | j                   }t        j                  j                         }||k(  sJ | d|        t        j                  j	                         5  d| _         t        j                  j                         5  t        j                  j                  d       	 d  || _         	 d d d        d d d        y # || _         w xY w# 1 sw Y   xY w# 1 sw Y   y xY ww)N, T)in_kernel_invocationrv   rw   _meta_in_tls_dispatch_include_DisableTorchDispatch_PreserveDispatchKeyGuard!_set_meta_in_tls_dispatch_include)r   prev_in_kernelmeta_in_tlss      rG   in_kernel_invocation_managerrI    s     
 33N((88:K.(L[MN;K*LL(		'	'	) 	@)-	& XX//1 	@HH66t<@1?	.	@		@ 	@ 2@	.	@ 	@		@ 	@sN   AC$&C C#C 'C/C7	C$ 	C		CC	CC!C$c                    t         j                  j                  | j                         j	                  d      d   j	                  d      d         S )Nz::.r   )rv   rw    _should_allow_numbers_as_tensorsnamesplitr   s    rG   should_allow_numbers_as_tensorsrP    sB    8844		$#))#.q1 rF   c                  J    e Zd Zej                  j                  dd      dk(  Zy)FakeTensorConfigTORCH_FAKE_TENSOR_DEBUG01N)rB   rC   rD   osenvironr   debugrE   rF   rG   rR  rR    s    JJNN4c:cAErF   rR  c                  z    e Zd ZU ded<   ded<   ddddZddZdd	Zdd
ZddZ	 d	 	 	 	 	 ddZ		 	 	 	 	 	 ddZ
y)SymNumberMemoDescriptorrZ   _namer   _is_nested_intFis_nested_intc                   || _         y rn   )r\  )rP   r^  s     rG   rQ   z SymNumberMemoDescriptor.__init__0  s
    +rF   c                    || _         y rn   r[  )rP   ownerrN  s      rG   __set_name__z$SymNumberMemoDescriptor.__set_name__3  s	    
rF   c                     d| j                    S )Nr   ra  rP   objs     rG   _memozSymNumberMemoDescriptor._memo6  s    4::,rF   c                "    d| j                    dS )Nr   _vcra  re  s     rG   _memo_vcz SymNumberMemoDescriptor._memo_vc9  s    4::,c""rF   c                "    d| j                    dS )Nr   _epochra  re  s     rG   _memo_epochz#SymNumberMemoDescriptor._memo_epoch@  s    4::,f%%rF   Nc                   t        || j                  |            x}y t        |t        j                        r|j
                  j                  |S | j                  s(t        || j                  |            |j                  k7  s>| j                  sOt        || j                  |            |j                  j                  k7  rt        || j                  |      d        y |S rn   )r   rg  r   rv   r   noder  r\  rj  _versionrm  r   epochsetattr)rP   rf  objtypers       rG   __get__zSymNumberMemoDescriptor.__get__C  s     djjo..A7 a(QVV[[-DH
 ##T]]35G(HCLL(X##T--c23s}}7J7JJCC$/rF   c                   |Ut        || j                  |      d        t        || j                  |      d        t        || j                  |      d        y |j	                         r| j
                  rt        || j                  |      |       | j
                  s&t        || j                  |      |j                         t        || j                  |      |j                  j                         y y rn   )	rr  rg  rj  rm  is_inferencer\  rp  r   rq  )rP   rf  r(  s      rG   __set__zSymNumberMemoDescriptor.__set__Y  s     =CC$/Cs+T2C))#.5!!#t':':CC%0&&T]]3/>C))#.0C0CD	 (;rF   )r^  r   rV   rW   )rb  rZ   rN  rZ   rV   rW   )rf  r   rV   rZ   rn   )rf  r   rs  zOptional[type[FakeTensor]]rV   -Optional[Union[torch.SymInt, torch.SymFloat]])rf  r   r(  ry  rV   rW   )rB   rC   rD   r]   rQ   rc  rg  rj  rm  ru  rx  rE   rF   rG   rZ  rZ  &  sp    J 05 , #& FJ(B	6,EE&SE	ErF   rZ  c                       e Zd ZU dZded<   ded<   ded<   ded<    e       Z e       Z e       Z e       Z	 ed	
      Z
ej                  j                  j                  Zedd       Zej$                  dd       Zedd       Zej$                  dd       Ze	 	 d	 	 	 	 	 	 	 	 	 	 	 dd       Zd fdZed d       Zeed e       f	 	 	 	 	 	 	 	 	 d!d              Ze	 	 	 	 	 	 d"d       Zdd	 	 	 d#dZd$dZ xZS )%r   al  
    Meta tensors give you the ability to run PyTorch code without having to
    actually do computation through tensors allocated on a `meta` device.
    Because the device is `meta`, meta tensors do not model device propagation.
    FakeTensor extends MetaTensors to also carry an additional `fake_device`
    which tracks devices that would have been used.
    r4  fake_devicer0  r   Optional[Tensor]r   real_tensorTr]  c                p    | j                   j                  rt        j                  d      S | j                  S Nr-  )r   rB  rv   r   r{  rO   s    rG   r   zFakeTensor.device  s*    >>..<<''###rF   c                    t         rn   NotImplementedErrorrP   r   s     rG   r   zFakeTensor.device      !!rF   c                    t        d      )Nz+torch.compile doesn't support named tensors)rY   rO   s    rG   nameszFakeTensor.names  s    ,9
 	
rF   c                    t         rn   r  r  s     rG   r  zFakeTensor.names  r  rF   c                   t        j                  | ||j                  d|      }|j                  s t        j
                  j                  |       nt        j
                  j                  |       |j                  j                  dk(  sJ |j                  j                         t        |t        j                        r|nt	        j                  |      }|j                  s|j                  dk7  sJ |j                  dv rt        |       |j                  ddddt        j
                  j                         fv r|j                  |j                  dk7  rst        t        |j                        j!                         rKt	        j                  |j                   d	t        t        |j                        j#                                }n"t	        j                  |j                   d
      }||_        ||_        ||_        t        |t*              rJ ||_        d |_        d |_        d |_        d |_        d |_        t8        j:                  rt=        j>                         |_         |S )NT)dispatch_devicedevice_for_backend_keysr-  )r8  r:  r8  hpur:  mps:z:0)!r   _make_subclassrequires_grad_allow_unsafe_data_ptr_accessrv   rw   _set_throw_on_mutable_data_ptr(_set_warn_deprecated_on_mutable_data_ptrr   r   r   
allow_metar?  _get_privateuse1_backend_nameindexr   is_initializedcurrent_devicer{  r   r   r   r}  nonzero_memor#  unique_memounique_consecutive_memonested_int_memorR  rX  r1   extract_debug_trace)clsr   r   r   r   r}  rP   s          rG   __new__zFakeTensor.__new__  s    $$ $*
 66HH33D9HH==dC{{6);4;;+;+;;)%fell;fAU ##;;&(((;;/)V$ KKueUXX-S-S-UVW${{e#v{{(C(R(R(T{{m1WUFKK%@%O%O%Q$RS R&89!" k:666& '+$#!! 1 9 9 ;DrF   c                "    t         |           y rn   )superrQ   )rP   argskwargs	__class__s      rG   rQ   zFakeTensor.__init__  s    rF   c                $    |j                  |       S rn   )from_tensor)r   r   s     rG   r  zFakeTensor.from_tensor  s    $$Q''rF   rE   c                   |t         j                  j                  j                  j                  k(  r`t        |      dk(  rt        |d   t              sJ |d   j                  j                  rt        j                  d      S |d   j                  S t        j                  |      x}r ||      S |D cg c]  }t        |t              r|t        us|  }}|rt        j                   d|       t"        S d }t%        j&                  |i |D ]   }	t        |	t              s|	j                  } n |J t         j(                  j+                  t         j(                  j,                  j.                        }
|
rt        j                   d||
       t"        S |j                  rJ |5   ||i |cd d d        S c c}w # 1 sw Y   y xY w)Nr2   r   r-  z(FakeTensor unrecognized subclass(es): %sz(FakeTensor mode already active: %s in %s)rv   opsprimr   defaultlenr   r   r   rB  r{  _DISPATCH_META_HANDLERSr   
issubclassr   not_implemented_logrX  r  r   arg_tree_leavesrw   _get_dispatch_modery   rz   )r  ra   typesr  r  handlerr   unrecognized_typesr   argmaybe_cur_fake_modes              rG   __torch_dispatch__zFakeTensor.__torch_dispatch__  s    599>>((000t9>ja*&EEEAw  55||F++Aw*** .11$77774=  
Jq*$=!6/A
 
 %%:<N "!	))4:6: 	C#z*MM		
 $$$ $hh99HH**//
 %%:#
 "!1111 	)((	) 	)K
J	) 	)s   5F8F8F8&F==Gc                     d d}d ddd fd}|D ]
  } ||        t               rd}t        j                  d      
J d         |fS )	NFc                ^    | j                   j                  dk(  xr | j                         dk(  S )Nr  r   )r   r   r  r   s    rG   cpu_zero_dimz4FakeTensor._find_common_device.<locals>.cpu_zero_dimZ  s$    88==E):aeegl:rF   c                    t        | t              sy | j                   |       y  |       }| j                  k(  rr|y |ry r| j                  |y t        d d d| j                         )Nz,Unhandled FakeTensor Device Propagation for z, found two different devices rA  )r   r   r   RuntimeError)r   t_is_cpu_zero_dimcommon_devicer  ra   is_cpu_zero_dims     rG   merge_devicesz5FakeTensor._find_common_device.<locals>.merge_devices]  s     a,$ !".q/ ,Qxx=("&7O !  !"3 >tfDbcpbqqstut|t|s}~ rF   Tr  z!Could not find common device for r   r   rV   r   )r   objectrV   rW   )rP  rv   r   )ra   	flat_argshas_scalar_only_inputsr  r  r  r  r  s   `    @@@rG   _find_common_devicezFakeTensor._find_common_deviceM  s     !&	; 	  	D  	C#	 +40]5J%)"!LL/M(T,MdV*TT(444rF   r2   )coeffc                   | j                   !| j                  j                  d       | _         t        | j                   t        j
                        sJ | j                   |z  S )Nnt_tensor_id)r  r   create_symbolic_nested_intr   rv   r   )rP   r  s     rG   get_nested_intzFakeTensor.get_nested_int  s]    
 '#'>>#L#L! $M $D  $..===##e++rF   c                    | j                         dk(  r| j                         S | j                         dk(  r| D cg c]  }|j                          c}S | D cg c]  }|j                          c}S c c}w c c}w Nr   r2   )r  r  tolist)rP   r   s     rG   r  zFakeTensor.tolist  s^    88:?99;XXZ1_,01DDIIK11.23dDKKM33 23s   A3A8)rV   r4  )r   r4  rV   rW   )rV   	list[str])r   r  rV   rW   )NN)r   r0  r   r   r   r4  r   r|  r}  r|  rV   r   )r  r  r  r  rV   rW   )r   r   r   r0  rV   r   
ra   r<   r  Sequence[type]r  Sequence[object]r  Mapping[str, object]rV   r  )ra   r<   r  r  rV   ztuple[torch.device, bool])r  zUnion[int, torch.SymInt]rV   torch.SymInt)rV   r   ) rB   rC   rD   __doc__r]   rZ  r  r#  r  r  r  rv   rw   ry   rz   	_mode_keyr5  r   setterr  staticmethodr  rQ   r  classmethodr0   r    r  r  r  r  __classcell__r  s   @rG   r   r   g  s    !!
 +,L')I)+K57
 .DAO ..33I$ $ ]]" "& 
 

 \\" "  &*(,;!; ; 	;
 #; &; 
; ;^ ( ( 

 "$'5'7G)G) G) 	G)
 %G) 
G)  G)R >5>5%5>5	">5 >5F +,
, (
, 
	
,4rF   r   r4   r5   c                      e Zd ZU dZ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<   ded<   ded<   	 	 	 	 	 	 	 	 ddZy) TensorMetadatazK
    The Tensor metadata relevant to hashing FakeTensors when caching.
    ztorch.dtyper  ztuple[_MetadataIntLike, ...]shapestrider4  r   ztorch.layoutr   zOptional[torch.memory_format]memory_format_MetadataIntLikestorage_offsetzOptional[_MetadataIntLike]storage_bytesr   r  r  is_conjis_negrw  r   rk   is_coalescedOptional[int]	dense_dim
sparse_dimc                >   t        j                  |       D ]  }t        | |j                        }t	        |t
        t        t        j                  f      r|j                  |||       Rt	        |t              r|j                  ||       u|j                  |        y rn   )dataclassesfieldsr   rN  r   tuplelistrv   Size_prep_args_for_hashr   convert_sym_intr   )rP   resultmodestatefieldr(  s         rG   _flatten_intozTensorMetadata._flatten_into  s}     !''- 		%ED%**-E%%uzz!:; ((>E6*%%fe4e$		%rF   N)r  list[object]r  r0  r  r3   rV   rW   )rB   rC   rD   r  r]   r  rE   rF   rG   r  r    s     ''((00$$--MLO  %% % 	%
 
%rF   r  c                   t        |       }| j                  st        |       s| j                  |      sd}| j	                         }t        | j                  | j                  | j                  t        j                  k(  r| j                         nd| j                  | j                  ||t        |       s| j                         j                         nd| j                  | j                   | j#                         | j%                         | j'                         | j(                  | j(                  r| j+                         ndt        |       r| j-                         ndt        |       r| j/                               S d      S )z1
    Extract the TensorMetadata of a tensor.
    )r  NrE   )r   _has_symbolic_sizes_stridesr   is_contiguousr  r  r  r  r   rv   r   r  r   untyped_storagenbytesr  r  r  r  rw  r   r  r  r  )r   r  r  s      rG   extract_tensor_metadatar    s    4I3KM 	
%%];%%'N		hh%--/
R		,9!,<""$$						
		KKT&q)t'*% $ 15% rF   c                  F    e Zd ZU dZded<   ded<   ddZddZddZdd	Zy
)_DispatchCacheKeyz0
    Key for the FakeTensor dispatch cache.
    tuple[object, ...]r   int	hashvaluec                2    || _         t        |      | _        y rn   )r   hashr  )rP   tups     rG   rQ   z_DispatchCacheKey.__init__  s    crF   c                X    t        |t              xr | j                  |j                  k(  S rn   )r   r  r   )rP   others     rG   __eq__z_DispatchCacheKey.__eq__  s"    %!23MEII8MMrF   c                    | j                   S rn   )r  rO   s    rG   __hash__z_DispatchCacheKey.__hash__  s    ~~rF   c                h    | j                   D ]#  }t        |t              s|j                          % y rn   )r   r   r4   strip_shape_env)rP   r   s     rG   r  z!_DispatchCacheKey.strip_shape_env  s-      	$A!_-!!#	$rF   N)r  r  rV   rW   )r  r  rV   r   )rV   r   rU   )	rB   rC   rD   r  r]   rQ   r  r	  r  rE   rF   rG   r  r    s)     
N#N$rF   r  T)frozenc                  0    e Zd ZU dZded<   ded<   ded<   y)_DispatchCacheEntryOutputInfoaV  
    Entry type for the FakeTensor dispatch cache for an output. Accounts for two
    possibilities:
    1) The op is inplace, and a hit means we need to alias the argument at a
       given index.
    2) We need to synthesize a new FakeTensor given tensor metadata. For view
       ops, we further capture the index of the arg to alias.
    r  inplace_idxzOptional[TensorMetadata]metadataview_idxNrB   rC   rD   r  r]   rE   rF   rG   r  r    s     &&rF   r  c                  *    e Zd ZU dZded<   dZded<   y)_DispatchCacheEntryz
    Entry type for the FakeTensor dispatch cache. It supports two types of outputs
    1) tensor
    2) tuple of tensors

    is_output_tuple flag helps in differentiating the return type
    z$tuple[_DispatchCacheEntryOutputInfo]output_infosFr   is_output_tupleN)rB   rC   rD   r  r]   r  rE   rF   rG   r  r  '  s     76!OT!rF   r  c                      e Zd ZU dZded<   y)_BypassDispatchCachez<
    Signals cases that should skip FakeTensor caching.
    rZ   r[   Nr  rE   rF   rG   r  r  6  s     KrF   r  c                  :    e Zd ZU dZded<   ded<   ded<   ded<   y)	DispatchCacheInfozG
    Information about the state of the FakeTensor dispatch cache.
    r   hitsmissesdict[str, int]bypassessizeNr  rE   rF   rG   r  r  @  s     IK
IrF   r  c                  l    e Zd ZU i Zded<   dZded<   dZded<    ee      Z	ded<   dZ
ded	<   d
Zded<   ded<   ded<   ded<   ded<   dZded<   dZded<   dd
ddd
d	 	 	 	 	 	 	 	 	 	 	 dE fdZdFdZdGdZedHd       ZedId       Zed e       f	 	 	 	 	 	 	 	 	 dJd       ZdK fd Z	 	 	 	 	 	 	 	 dL fd!ZedHd"       ZedMd#       ZedFd$       Z	 	 	 	 	 	 	 	 	 	 dJd%Z	 	 	 	 	 	 	 	 	 	 dNd&Z	 	 	 	 	 	 	 	 dOd'Z	 	 	 	 	 	 	 	 dPd(Z 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dQd)Z!	 	 	 	 	 	 	 	 	 	 	 	 	 	 dRd*Z"	 	 	 	 	 	 	 	 	 	 	 	 	 	 dSd+Z#	 	 	 	 	 	 	 	 	 	 	 	 dTd,Z$	 	 	 	 	 	 	 	 	 	 	 	 dUd-Z%	 	 	 	 	 	 	 	 	 	 	 	 dVd.Z&d e       f	 	 	 	 	 	 	 	 	 dJd/Z'	 	 	 	 	 	 	 	 	 	 dWd0Z(	 	 	 	 	 	 	 	 	 	 	 	 dXd1Z)	 	 	 	 	 	 	 	 	 	 dYd2Z* e+d3d4d5d6d7d8d9d:      Z,dZd;Z-	 	 	 	 	 	 	 	 	 	 d[d<Z.	 	 	 	 	 	 	 	 	 	 d\d=Z/dd>	 	 	 d]d?Z0 e+e1jd                  jf                  e1jh                  jj                  e1jl                  jj                  e1jn                  jj                  e1jp                  jj                  e1jr                  jj                  e1jt                  jj                  e1jv                  jj                  e1jx                  jj                  e1jz                  j|                  e1j~                  jj                        Z@dZd@ZA e+e1j                  jj                  e1j                  jj                        ZDd^dAZE	 	 	 	 	 	 	 	 	 	 d_dBZFdddddC	 	 	 	 	 	 	 	 	 	 	 d`dDZG xZHS )ar0  z,dict[_DispatchCacheKey, _DispatchCacheEntry]cacher   r   
cache_hitscache_missesr  cache_bypassesrq  Fr   rB  static_shapesr1  r   zOptional[str]_stackr  rK  nt_tensor_id_counternt_tensor_id_initial_countTN)allow_fallback_kernelsallow_non_fake_inputsr   r%  r   c                  t         j                  dt        |              t        |           || _        dd l}dd l}|j                  j                  j                  | _        t        | j                  |      | _        ||| _        n	|d u | _        d| _        |j                  j                  j                   | _        |j                  j                  j$                  | _        |j(                  j                  j*                  xr | j                   | _        |j(                  j                  j.                  | _        || _        d| _        g | _        || _        t;        j<                         | _        d | _         |jB                  jD                  jF                  | _$        dd l%}|jL                  jN                  jP                  jR                  | _*        | jT                  | _+        y )Nzcreate_mode 0x%xr   r   F),logrX  idr  rQ   r)  torch._dynamo.configtorch._functorch.configr   config"fake_tensor_propagate_real_tensorspropagate_real_tensorsr   fake_tensor_converterr%  allow_scalar_outputs(fake_tensor_allow_unsafe_data_ptr_accessr  fake_tensor_allow_metar  _dynamofake_tensor_cache_enabledcache_enabled$fake_tensor_cache_crosscheck_enabledcache_crosscheck_enabledr*  rB  enter_stackr   	tracebackextract_stack_stack_tracer&  rw   ry   rz   r  $torch.nested._internal.nested_tensornested	_internalnested_tensor_tensor_id_counterr(  r'  )rP   r)  r*  r   r%  r   rv   r  s          rG   rQ   zFakeTensorMode.__init__n  s   $ 			$bh/&<##& ##FF 	# &911&
"
 $!.D!*d!2D %*! ##LL 	*  **11HHMM  :: 0/// 	
 MM  EE 	% &;" %*!  	 #%335 77<<3 LL""00CC 	' %)$C$C!rF   c                &    | j                   | _        y rn   )r(  r'  rO   s    rG   reset_nt_tensor_id_counterz)FakeTensorMode.reset_nt_tensor_id_counter  s    $($C$C!rF   c                B    t        |t              xr |j                  | u S rn   )r   r   r   rP   r   s     rG   is_our_fakezFakeTensorMode.is_our_fake  s    !Z(@Q[[D-@@rF   c                ^   t         j                  j                         r?t         j                  j                         rJ t         j                  j	                          S t         j                  j	                         xs0 t        t         d      xr t         j                  j	                          S )Nr  )rv   r:  _is_compiledr8  r9  hasattrr  rO   s    rG   avoid_device_initz FakeTensorMode.avoid_device_init  s|    99!!#zz..000yy--/// JJ##% Du%B%))*@*@*B
 	
rF   c                    | j                   3dj                  t        j                  | j                              | _         | j                   S )N )r&  joinr=  format_listr?  rO   s    rG   stackzFakeTensorMode.stack  s7    ;;'')"7"78I8I"JKDK{{rF   rE   c                   t         j                  j                  t         j                  j                  j                        J |       	 | j                  ||||      S # t        $ r t        j                  d        w xY w)Nzfake tensor raised TypeError)	rv   rw   r  ry   rz   dispatch	TypeErrorr,  	exception)rP   ra   r  r  r  s        rG   r  z!FakeTensorMode.__torch_dispatch__  sr     HH''(F(F(K(KLT		T	==udF;; 	MM89	s   
A  A>c                   dd l }d }| j                  r5|j                  j                         }|j                  j	                  d       |j                  j                  | j                        }| |ur,| j                  j                  d||f       t        | )         S |j                  j                  |        | j                  j                  dd |f       | S )Nr   TF)r@  rM  rw   _only_lift_cpu_tensors_set_only_lift_cpu_tensorsrx   r  r<  r   r  	__enter__r{   )rP   rv   prev_only_lift_cpu_tensorsmaybe_prev_fake_moder  s       rG   rZ  zFakeTensorMode.__enter__  s    3%)"!!).)H)H)J&HH//5$xx<<T^^L++##+-GH 7$&& HH''-##UD2L$MNrF   c                    | j                   j                         \  }}}|rUt        |   |||       |t        j
                  j                  |       | t        j
                  j                  |       y y y rn   )r<  r   r  __exit__rv   rw   r{   rY  )rP   abcliver\   maybe_prev_only_lift_cpu_tensorsr  s          rG   r^  zFakeTensorMode.__exit__  sw       "		
 ,GQ1% $/++,@A/;334TU < rF   c                     yrp   rE   r  s    rG   is_infra_modezFakeTensorMode.is_infra_mode0  s    rF   c                    t        t        j                  t        j                  t	        t        j
                        t        t        j                              S )z8
        Query the state of the dispatch cache.
        )r  r0  r"  r#  rq   r$  r  r!  re  s    rG   
cache_infozFakeTensorMode.cache_info4  s?    
 !%%''../$$%	
 	
rF   c                    d| _         d| _        | j                  j                          | j                  j                          y)z+
        Clear the dispatch cache.
        r   N)r"  r#  r$  clearr!  re  s    rG   cache_clearzFakeTensorMode.cache_clear@  s3    
   "		rF   c                <   t         }	 t        | j                        }| j                  ||||      }|j	                         r%|j                  J |j                  j
                  }nt        j                  }|j                  |d      }	|	P| j                  ||	|||      }t        xj                  dz  c_
        | j                  r| j                  |||||       nk| j                  |||       | j                  ||||      }| j                  ||||||      }	|j!                          |	||<   t        xj"                  dz  c_        |t         u r| j                  ||||      }|S # t$        $ r/}
t        j&                  |
j(                  xx   dz  cc<   Y d}
~
Qd}
~
ww xY w)z
        Lookup a cache entry for the given arguments. If none exists, dispatch
        and cache the result (if the result is eligible for caching).
        Nr2   )_UNASSIGNEDr3   r   
_cache_keycache_on_shape_envfake_tensor_cacher0  r!  r   _output_from_cache_entryr"  r;  _crosscheck_cache_output_validate_cache_key_dispatch_impl_make_cache_entryr  r#  r  r$  r[   )rP   ra   r  r  r  outputr  r   r!  entryes              rG   _cached_dispatch_implz$FakeTensorMode._cached_dispatch_implJ  s    %	9"4>>2E//%tV<C'')22299&,,IIc4(E 66ueS$PTU))Q.)00 11&$tVT((tV<,,T5$G..uc4vvV##%"c
++q0+ [ ((udFCF $ 	9))!((3q833	9s   D=E# #	F,%FFc                P   |t        j                         t         j                  j                         t        j                         | j
                  r| j
                  j                  ndg}|r| j                  |||       |r| j                  |||       t        t        |            S )z
        Create a cache key given the dispatch args. Raises _BypassDispatchCache
        for any situation that precludes caching.
        N)
rv   get_default_dtyperw   _get_default_deviceis_inference_mode_enabledr   settingsr  r  r  )rP   r  ra   r  r  
key_valuess         rG   rn  zFakeTensorMode._cache_keyu  s      ##% HH((* ++- (,~~DNN##4

" $$Zu=$$Z? z!233rF   c                    t         j                  j                  |j                  v rt	        d      t         j                  j
                  |j                  v rt	        d      t         j                  j                  |j                  v rt	        d      |t        j                  j                  k(  rt	        d      || j                  v rt	        d      |j                         dk(  rt	        d      t         j                  j                  j                  |      st	        d      |j                  r\t         j                   j#                  |j                         t         j                   j$                  j&                        rt	        d      y	y	)
za
        Validate that the cache key generated by _cache_key will be
        reasonable.
        zdata dependent outputzdynamic output shapezinplace viewzunsafe viewliftzinductor::resize_storage_bytes_znon-builtinCompositeImplicitAutogradN)rv   Tagdata_dependent_outputtagsr  dynamic_output_shapeinplace_viewaten_unsafe_viewr  lift_fnsrN  _libraryutils
is_builtinis_viewrw   %_dispatch_has_kernel_for_dispatch_keyDispatchKeyr  )rP   ra   r  r  s       rG   rs  z"FakeTensorMode._validate_cache_key  s'    99**dii7&'>??99))TYY6&'=>>99!!TYY.&~664$$,,,&}554== &v..99;;;&'HII~~##..t4&}55
 <<EHHJJIIK--GG
 ''BCC
<rF   c                   t        |t              rC| j                  ||j                         |       | j                  ||j	                         |       y|D ]y  }t        |t
              r| j                  |      st        d      |j                  t        d      t        |      rt        |j                   d      t        |j                         j                         t              rt        d      t        |      }|j                  || |       t        |t               rt        d      t        |t              r|j#                  ||       t        |t$        t&        f      rt        d      t        |t(        t*        t        f      r| j                  |||       O|j-                  t/        |             |j-                  |       | y)a7  
        Translate the provided args into a form suitable for caching at FakeTensor
        dispatch, i.e., convert unhashable types like lists & dicts into tuples and
        convert FakeTensors into metadata. Raises _BypassDispatchCache to signal
        unsupported cases that should bypass caching.
        Nznot our fakeconstant attributez tensorzsymbolic nbytesznon-fake tensorzsymbolic shape)r   rq   r  keysvaluesr   rI  r  r   r   r   r  r  r   r  r  r   r  r   r   r  r  r   r   )rP   r  r  r  r  r  s         rG   r  z"FakeTensorMode._prep_args_for_hash  sy    dD!$$VTYY[%@$$VT[[]EB 	#C#z*'',.~>><<+./CDD %.#**W/EFF c113::<fE./@AA237&&vtU;C(*+<==C(%%fc2C'8!45*+;<<C$t!45((e<
 d3i(c"7	#rF   c                0   t        |t              st        d      |j                  t        d      |j                  rt        d      t        |      rt        d      |j                         D ]$  }t        |      t        |      k(  st        d       y )Nznon-FakeTensor outputr  zsparse outputzsparse compressed outputzkwarg aliases output)r   r   r  r   r   r   r  r-  )rP   r  r   ra   r  r  rv  kvals           rG    _validate_output_for_cache_entryz/FakeTensorMode._validate_output_for_cache_entry  s     &*-&'>?? ??&&';<< &77'&'ABB MMO 	CD$x2f:%*+ABB	CrF   c                x   t        t        |            D ],  }t        ||         t        |      k(  st        |d d       c S  d }|j                  rCt        |      D 	
cg c]  \  }	}
t        |
t              s|	 }}	}
t        |      dk(  sJ |d   }t        |      }t        fd|j                  D              |_
        t        fd|j                  D              |_        j                  |j                        |_        |j                  d nj                  |j                        |_        t        d ||      }t        |fd      }| j!                  ||||      }t"        j$                  j'                  |      }t"        j$                  j'                  |      }||k7  rt)        d      |S c c}
}	w )	Nr  r  r  r2   r   c              3  @   K   | ]  }j                  |        y wrn   convert_outputr   r   r  s     rG   r   zBFakeTensorMode._get_output_info_for_cache_entry.<locals>.<genexpr>'  s     O1u33A6O   c              3  @   K   | ]  }j                  |        y wrn   r  r  s     rG   r   zBFakeTensorMode._get_output_info_for_cache_entry.<locals>.<genexpr>(  s     QA 4 4Q 7Qr  Fr  r  zdispatch_key_set mismatch)ranger  r-  r  r  	enumerater   r   r  r  r  r  r  r  r  r  rq  rv   rw   _dispatch_key_setr  )rP   r  r   ra   r  r  rv  idxr  ir   idxsr  rw  entry_for_synth_outputsynth_outputsynth_key_setkey_sets    `                rG    _get_output_info_for_cache_entryz/FakeTensorMode._get_output_info_for_cache_entry  s    T# 	C$s)}6
*4 #dT 	 <<"+D/K$!QZ65JAKDKt9>!>AwH*62OOOQQQ"'"6"6x7N7N"O %%- %%h&<&<= 	 .
 "55"
 44)3d
 22<@((,,V4G#&'BCCO Ls   !F6:F6c                   |t        ddd      }t        |fd      S t        |t              r|D ]  }| j	                  ||||||        n| j	                  ||||||       t        |t              r9|D 	cg c]  }	| j                  ||||||	       }
}	t        t        |
      d      S | j                  ||||||      }t        |fd      S c c}	w )z
        Make a cache entry object for the given 'output' Tensor. Raises
        _BypassDispatchCache if the output tensor has characteristics that
        prevent caching it.
        Nr  Fr  T)r  r  r   r  r  r  )rP   r  r   ra   r  r  rv  output_infoout_elementout_elemr  s              rG   ru  z FakeTensorMode._make_cache_entryK  s    >7 4$K ')^U  fe$% 553dFK
 11sD$ fe$
 !'	  553dFHL  '"<0$ 
 ??sD$K ')^U s   7Cc           
        |j                   #||j                      }t        |t              sJ |S |j                  }|y t	        |      rJ 	 	 	 	 	 	 dfdt        fd|j                  D              }t        fd|j                  D              }	 |j                        }
|j                   |j                         t        j                  }| j                  | j                  j                  }t        |       5   |       5  t        j                   ||	|j"                  |j$                  d|j&                        }d d d        d d d        |j(                  r t        j*                  j-                  d       |j.                  r t        j*                  j1                  d       |j2                  rw|t5        t6        |j8                           }t        |t              sJ |j;                         }t        |       5   |       5  j=                  ||
||	       d d d        d d d        t        | |j>                        S # 1 sw Y   xY w# 1 sw Y   	xY w# 1 sw Y   BxY w# 1 sw Y   FxY w)Nc                    t        | t              r*|j                  J | j                  |j                        S t        | t              rJ | S rn   )r   r5   r   r  r4   )r(  r  r   s     rG   check_valuezGFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.check_value  sJ     %!23222}}S%//::%e_===rF   c              3  0   K   | ]  } |        y wrn   rE   r   r   r  r  s     rG   r   zEFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.<genexpr>  s     Dk!U+D   c              3  0   K   | ]  } |        y wrn   rE   r  s     rG   r   zEFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.<genexpr>  s     F{1e,Fr  r-  )r  r   r   r  T)r(  r  r  r3   rV   zUnion[IntLikeType]) r  r   r   r  r   r  r  r  r  r  
contextlibnullcontextr   suppress_guardsrI  rv   empty_stridedr  r   r  r  rw   	_set_conjr  _set_negr  r   r   r  r  set_r   )rP   r  rw  r   ra   r  inplace_argr  r  r  r  maybe_suppressr=  view_argstorager  s    ` `           @rG   #_get_output_tensor_from_cache_entryz2FakeTensorMode._get_output_tensor_from_cache_entry~  s3    (u001Kk:666 >> ***	#	,:		 DX^^DDFhooFF$X%<%<eD!!-..6>H>T>T>>%!^^;;N)$/ 	1A 	''nn&44E	 	 HHud+??HHeT*<<Denn56Hh
333..0G-d3 C^5E C

7NE6BC C $x77/	 	 	 	(C C C CsH   I:I
II2I&%I2I	II#&I/	+I22I;c           
         |j                   r7|j                  D cg c]  }| j                  |||||       }}t        |      S | j                  ||j                  d   |||      S c c}w )z?
        Create a new FakeTensor from the cache entry.
        r   )r  r  r  r  )rP   r  rw  r   ra   r  r  outputss           rG   rq  z'FakeTensorMode._output_from_cache_entry  s        $)#5#5	   88	G 	 >!;;u))!,c4 	s   A&c                   	 | j                  ||||      }	 |u|st        |t              r?t        |      t        |      k(  sJ t        ||      D ]  \  }}	t        t        ||	        yt        |t              rJ t        t        ||       y|J |J y# t        $ r}t        d| d| d| d|       |d}~ww xY w# t        $ r}t        d| d| d|       |d}~ww xY w)z
        Helper to validate that the output synthesized from the cache matches
        the output created by normal dispatch.
        z*FakeTensor cache crosscheck failure: func=z, args=z	, kwargs=z: Dispatch raised=N)	rt  	Exceptionr  r   r  r  zipr   r   )
rP   rv  ra   r  r  r  true_outputrx  r_  r`  s
             rG   rr  z'FakeTensorMode._crosscheck_cache_output  s1   	--dE4HK	'f.@k51{+s6{::: #K 8 <1*9a;<  *&%888&y+vF"***~%~!  	<TF CvYvh.@E 	"  	<TF CvYvh0 	s;   B AC  *#C  C  	B= B88B= 	C#	CC#c                   |xs i }t               5  t        j                  d|||       d d d        |t        v rt        |   |      S t        j	                         t
        j                  k  r(t        j                  ddt        z  |       t               }|t        v rt        |       5   ||i |cd d d        S | j                  r| j                  ||||      S | j                  ||||      S # 1 sw Y   xY w# 1 sw Y   IxY w)Nz%s %s %sz'%sFakeTensorMode.__torch_dispatch__: %s )r'   r,  rX  r  getEffectiveLevelloggingDEBUGrN   rJ   _DISPATCH_HANDLE_DIRECTLYrI  r9  ry  rt  )rP   ra   r  r  r  incrs         rG   rT  zFakeTensorMode.dispatch  s     2] 	6IIj$f5	6 ***4066  "gmm3II93;PRV +,D ,,-d3 -T,V,- - --dE4HH&&tUD&AA/	6 	6"- -s   C.(C:.C7:Dc                   
 ddl ddlm} d fd}t        |t        j
                        rZ	  |||ddddd       t        t        |j                         |j                                     D ]  \  }\  }}		  |||	        |dfS 	  |||       |dfS # t        $ ro
t        j                  j                  j                  r%t        d	
fd
       t         |      dfcY d

S t        d| d| dt        |       d       
d

ww xY w# t        $ rt
t        j                  j                  j                  r't        d	
fd       t         |      dfcY d

c S t        d| d|	 dt        |       d| d 
      
d

ww xY w# t        $ r&
t        d| d| dt        |       d       
d

ww xY w)z
        Helper to cross-check fake/real output properties & values,
        and create new fake vals if mismatched.
        Returns tuple of object & boolean, for whether or not it was overwrriten
        r   N)_check_fake_real_tensorsc                ^   t        | t        t        f      rj                  J | j                  j
                  j                  j                  j                  j                         z
  j                  j                  j                         z
  sjj                  j                  j                  | j                  j
                  |      d      j                  j                  urt        d|  d| d      y y t        | t        t         t"        f      r| |k7  rt        d|  d| d      y y )NT)compute_hintzmismatch between fake value z and real value r  )r   r   r   r   ro  exprfree_symbols
var_to_valr  unbacked_var_to_val_maybe_evaluate_staticEqStruerh   r   floatr   )fakerealrP   sympys     rG   _check_fake_real_valsz?FakeTensorMode._maybe_infer_fake.<locals>._check_fake_real_vals/  s'   $ 23~~111		33nn//4467nn88==?@
 ==!HHTYY^^T: >   %ww||,
 4:4&@PQUPVVWX ,@ sE4( 4</6tf<LTFRST   rF   Real tensor propagation foundFT)contextsizesstridesr  r  mismatched_fake_kernelc                 4    t               j                  dS Nopr[   rZ   r[   excra   s   rG   <lambda>z2FakeTensorMode._maybe_infer_fake.<locals>.<lambda>Y  s    "%d)&)jj- rF   metadata_fnzFReal tensor propagation found a metadata mismatch between fake tensor z and real tensor z,  at outputz, for func: c                 4    t               j                  dS r  r  r  s   rG   r  z2FakeTensorMode._maybe_infer_fake.<locals>.<lambda>n  s    &)$i*-**1 rF   zIReal tensor propagation found an output size mismatch between fake shape z and real shape z, at outputz.size(z), for func: zQReal tensor propagation found an output value mismatch between fake output value z and real output value )r  r   r  r   rV   rW   )r  torch._subclasses.fake_utilsr  r   rv   r   rh   r   r0  *generate_fake_kernels_from_real_mismatchesr   _infer_fake_from_real_tensorr+   r  r  r  )rP   ra   pathr  r  r  r  js_fakes_realr  r  s   ``        @@rG   _maybe_infer_fakez FakeTensorMode._maybe_infer_fake#  s    	I	6 dELL)(;!#'"'2 (1TYY[$))+1N'O ##FF)&&9: U{%dD1 U{[ ) ##**UU%0% 8dDI4OO+##'&(9$ @!!'l4&B 	& - ((//ZZ)4)  <D$MtSS/&&,X-=fX F$$*4L>s-vO 	( ) +))-.EdV L  &t~\$A 	sa   B ;	D	F 	D!AD$D*!DD	FAFF'$FF	G!F==Gc                    ddl m} d j                  rt         j                  j                        d fd}t
        j                  |      \  }}	t
        j                  |      \  }
}	  |d||||       t        t        ||
      D cg c]  \  \  }}} j!                  |||       c}}} \  }}t#        |      r	r |        t
        j%                  ||	      S # t        $ rkt        j                  j                  j                  r-t        dfd        |        t         fd	|      cY dS t        d
| d| d       dww xY wc c}}}w )z
        Helper to cross-check fake/real output properties & values,
        and create new fake vals if mismatched, but at the kernel level.
        Means this handles pytree outputs & checks aliasing.
        r   )_check_alias_infoNc                     t        t        j                  j                        j	                               j                  _        y rn   )r  setr   pending_fresh_unbacked_symbols
difference)pending_unbackedrP   s   rG   _clear_pending_unbackedzXFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>._clear_pending_unbacked  s4    <@DNNAABMM$=DNN9rF   r  r  c                 :    t              d j                   dS )Nz>Mismatched aliasing spec between fake kernel and real kernel: r  r  r  s   rG   r  zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>.<lambda>  s#    !$i\]`]g]g\hi) rF   r  c                    t        |       S rn   )r  )r   ra   rP   s    rG   r  zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>.<lambda>  s    :4qI rF   zGReal tensor propagation found an aliasing mismatch between fake output z and real output z,  for func: rU   )r  r  r   r  r  r   tree_flatten_with_pathtree_flattenrh   rv   r   r0  r  r   r-   r  r  r   tree_unflatten)rP   ra   fake_inreal_infake_outreal_outr  r   fake_paths_leaves	fake_specreal_leavesr   
_fake_path	_fake_out	_real_outfake_leaves	overridesr  r  s   ``               @@rG   (_maybe_infer_fake_kernel_from_pytree_outz7FakeTensorMode._maybe_infer_fake_kernel_from_pytree_out  sx    	C  >>#DNN$Q$QR	 (.'D'DX'N$9,,X6Q	/7Hg> "% ;>%{; 6+ZY &&tZIN"
Y 	N/#%$$[)<<Q % 	&&QQ!,! ()I8  ,##+*,=hZ H""&) 	)	:s+   0C% !E%	E.AE9E?EEc                H   )*+,-./01234 t         j                  f      \  -)t        -      }|r@-D cg c]  }t        |      st	        |       }}t        j                  d|       t        S -D cg c]  } j                  |      s| }	}t        d |	D              xs t        d -D              / j                  + j                  v }
t        j                  j                  j                  j                   u xr; t#        d   t        j$                        xr d   j&                  j                  dk(  }|
r|	rt)              rȉ/s|	s|st+        d |	D              s
J  d       -D cg c]!  } j                  |      r|j,                  n|# }}t         j/                  |)      \  }} |i |}t	        |      t$        u rH j1                  |      r7t3               5  |j5                         }d d d        +j7                   |d	      S |
rQt9              dk(  rt9              d
k(  sJ  d        t	        d         t$        u r+j7                   d         S d} j:                  rrt        j                  j                  j                  j                   k(  rdv r
d   dk7  rd}t        j                  j<                  j>                  j                   k(  rd} jA                  +-)      \  -}	t+        d |	D              }t        jB                  jD                  jF                  vrt        jB                  jH                  jF                  vr|rt9        |	      dk7  r/s|s-D cg c]!  } j                  |      r|j,                  n|# }}t         j/                  |)      \  }}t3               5   |i |}d d d        t         jK                        }|D cg c]  }t#        |t$              s| }}t+         fd|D              }|rt         jM                  t$        + fd|      S |D ]  }+jO                  |        t         j/                  -)      \   jQ                  |	       	 	 	 	 d& fd}ddl)m**m+. tY               003 jZ                  rt+        d |	D              rt        . 4fd-D              st\        j                  d       -D cg c]
  } ||       }}t         j/                  |)      \  12t_        j`                        }|st_        jb                  |)      }	  1i 23|syjg                          t_        jh                  jj                  -3       nG jZ                  r;t\        j                  d|	- jl                  r jl                  jn                  nd        d'*.0123 f
d}/r-tq               js                        }| | | gi       S ddl:m;} |vr jy                        s}ddl:m=} |v r</st}              r/t+        d |	D              r 5   | |   i       cd d d        S  5   j~                  i }|t        ur ||      cd d d        S 	 d d d        dj                  j                  v r;t        d      r/t              s$ 5   | j                  i       cd d d        S t        j                  j                  j                  } | %| j                  v r | j                   gi S  jZ                  r_30ur[t_        j`                        sF jl                  :t_        j                        s%t         3      }!t        dfd !        ||!      S t        j                  j                  j                  j                  j                               j                  j                  }"|"r|t        j                  j                  j                         ,t        j                  j                  j                  ,fd"      5   5   |"i }! ||!      cd d d        cd d d        S t        D ]-  \  }#}$ |#      s |$ gi }%|%t        us% ||%      c S  	 d(	 	 	 d))-/ fd#}&t              s |&       }' ||'      S 	 t               5   i }d d d         | j                  -js                  d      %            S c c}w c c}w c c}w # 1 sw Y   ;xY wc c}w # 1 sw Y   zxY wc c}w c c}w # td        $ r"}t\        j                  d|       Y d }~1d }~ww xY w# 1 sw Y   )xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   nxY wd d d        I# 1 sw Y   SxY w# 1 sw Y   xY w# t        $ r}( |&|(      cY d }(~(S d }(~(wt        $ r t\        j                  d$        w xY w)*Nz,FakeTensorMode unrecognized subclass(es): %sc              3  4   K   | ]  }|j                     y wrn   )r  )r   r  s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>  s      !
./A))!
   c              3  <   K   | ]  }t        |t                y wrn   )r   r   )r   r_  s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>  s     :1Av&:s   r   r-  c              3  8   K   | ]  }|j                   d u  y wrn   r   r   r   s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>  s      +,

$&   z. should not have fake inputs without constantsTr%  r2   r  Fr   r  c              3  8   K   | ]  }|j                   d u  y wrn   r   r   rx  s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>C       Qa1::T1Qr  c              3  @   K   | ]  }j                  |        y wrn   )may_turn_const)r   r   rP   s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>X  s     P!t2215Pr  c                ,    j                  | d      S )NTr  )r+  )r   	converterrP   s    rG   r  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>]  s    i88qPT8U rF   c                   t        | t              r| j                  S t        | t              rj                  J | j
                  j                  | j
                  j                  j                  j                  j                        j                  j                  j                              S t        | t              r| j                  S | S rn   )r   r   r}  r%   r   ro  pytyper  xreplacer  r  r   real_obj)r   rP   s    rG   maybe_to_real_tensorz;FakeTensorMode._dispatch_impl.<locals>.maybe_to_real_tensork  s     !Z(}}$A|,~~111vv}}FFKK(()B)BCLL:: 
 A/0zz!rF   )compute_unbacked_bindingsfree_unbacked_symbolsc              3  8   K   | ]  }|j                   d u  y wrn   )r}  r  s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>  s     M!AMM-Mr  c              3     K   | ]F  }t        |t              xr0  |      xxr$ j                  d uxr t        fdD               H y w)Nc              3  N   K   | ]  }|j                   j                  v  y wrn   )r   r  )r   srP   s     rG   r   z:FakeTensorMode._dispatch_impl.<locals>.<genexpr>.<genexpr>  s      VAAT^^%G%GGVs   "%)r   r   r   r   )r   r_  r(  rP   symss     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>  sd        q&) W!6q!99Wd2W VQUVVWs   AAzpropagate_real_tensors %sz9real-tensor fallback failed for %s: %s; silently ignoringz,SKIPPED propagate_real_tensors %s(%s, %s) %sc           	     F  
 dd l t        j                  d       dfdurt        j                  j
                  j                  sj                  f	
f|        nj                  f	
f|       } t        | t              smt        t              s]t        |       t              k7  rFt        t        t        j                  |             t        t        j                                     nt        |         j                  | d       | S )Nr   zmaybe_propagate_real_tensors %sc                   t        | t              rt        j                  dt	        |       t	        |             || _        t        | j                         |j                               D ]  \  }} ||        t        | j                         |j                               D ]  \  }} ||         | j                         |j                                y t        | t              r |       rt        | j                  j                  j                        r?j                  J j                  j                  | j                  j                  |       y t        | j                  j                  x}j                         ret        |j"                  j                        rD|j$                  dk(  r4j                  J j                  j                  |t'        |             y y y y y y )Nz%maybe_propagate_real_tensors %s -> %sr2   )r   r   r,  rX  r-  r}  r  r  r  r  r%   ro  r  Symbolr   set_unbacked_var_to_valr  lhsrhsr   )r   real_tr,  real_sr(  gorP   r  s       rG   r6  zOFakeTensorMode._dispatch_impl.<locals>.maybe_propagate_real_tensors.<locals>.go  sw   a,II?A6
 %+AM%(6;;=%A &	61f&%(V]]_%E &	61f&q'')6+@+@+BC<05J15M!!&&++u||<#~~999>>qvv{{FS"#31UXX>&quuell;EEQJ#~~999>>q#f+N ' < ? 6N0rF   T)peek)r   r  r4  r   rV   rW   )r  r,  rX  rv   r   r0  r  r  r   r   r   r.   r  r   r  r   )r  r6  r  r  r'  r(  ra   r  nil	real_argsreal_kwargsr	  rP   s    @@rG   maybe_propagate_real_tensorszCFakeTensorMode._dispatch_impl.<locals>.maybe_propagate_real_tensors  s   II7>O O0 s" ((//ZZAAv"K0    $LLv"K0   H #8V4&x8X$x.8 f11(;<f11(;< b(H5
 *$..(NOrF   )
meta_tabler   c              3  4   K   | ]  }t        |         y wrn   )r   r  s     rG   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>	  s     PQa 00Pr  zprims::prim_meta_implmissing_fake_kernelc                     dt               iS )Nr  )rZ   r   s   rG   r  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>G	  s    c$i) rF   r  c                      S rn   rE   )ctxs   rG   r  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>T	  s     rF   c                    t         j                  j                  j                        ry sj	                        st              | t              } t        |       S rn   )rv   r  r  can_generate_trivial_fake_implcan_run_unsafe_fallbackrf   run_fallback_kernel)error	args_specr  ra   has_symbolic_sizesrP   s    rG   maybe_run_unsafe_fallbackz@FakeTensorMode._dispatch_impl.<locals>.maybe_run_unsafe_fallbacka	  s]     ~~##BB4H!)E)Ed)K2488}4T:&tT9iOOrF   z*failed while attempting to run meta for %sr7  )r   rH   rV   z1Optional[Union[T, Tensor, torch._C.ScriptObject]])r  rH   rV   rH   rn   )rG  zOptional[RuntimeError]rV   r/  )\r   r  _check_for_subclass_check_for_subclass_argr   r  rX  r  rI  r   r3  r  rv   r  r  _to_copyr  r   r   r   rP  r   r   r  r  r'   cloner+  r  rM  prims
device_put%validate_and_convert_non_fake_tensorsr  nondeterministic_seededr  r  r   tree_map_onlyr   invalidate_written_to_constantsr  r'  r(  r  r2  r,  library_utilsr  MutationCheckerZeroDivisionErrorcheckcheck_aliasing_constraintr[  r   r  get_fast_op_implsr   r   r<  cpp_meta_supports_symintr   r   	decomposer   rN  rL  stride_incorrect_opr>  r7  r0  _custom_ops_profiledatageneric_fake_kernelhas_fake_kernel"inferred_fake_kernel_from_real_outr   r  simple_registry	singletonfind	fake_implkernelFakeImplCtxset_ctx_getterop_implementations_checkshas_metarI  r  r  rV  +wrap_meta_outputs_with_default_device_logic)5rP   ra   r  r  r  has_unrecognized_typesr   r  r   flat_arg_fake_tensorsis_lift_func!device_conversion_skip_const_propr_  const_flat_args
const_argsconst_kwargsr   avoiding_device_initall_constantflat_outflat_out_tensorsr   r&  real_flat_argsr  mutation_checkerr  r;  	fast_implr<  r   rt  profilesr  maybe_fake_implrun_impl_checkop_implop_impl_outrJ  fallbacknot_implemented_errorrH  r'  r!  rB  r  r(  rI  r8  r9  r:  r	  r-  s5   `` ``                                    @@@@@@@@@@@@rG   rt  zFakeTensorMode._dispatch_impl  s
     &22D&>B	9 "5Y!?!!*".Ea.HQ" "  %%>@R "!,5 Mq9I9I!9L M M  !
3H!
 
 ;:	:: 	 ..	t}},EIINN++333 .47ELL1.Q##v- 	* !6+D1&)5 0E  GEFG  CL=>d..q1

q8O  (.'<'<_i'X$J
3l3CCyF"t':':3'? !] &))+C& 11$41PP v;!#D	QJ4&&8JJ6DG}& 11$Q@@  %!!		//777&8$-'+$uyy11999'+$ .2-W-W)Y	.
*) & Q;PQQII--TYY>		&&dii7)*a/&( CL=>d..q1

q8O  (.'<'<_i'X$J  8J7,78 ))#.H+3Maz!V7LMMP?OPPL++U  ( ;55c:;
 ,,Y	Bf,,T3H$PVW		>	"	

 h''M7LMM  #  II148?HI!215INI%+%:%:>9%U"I{&11$7J#0#@#@.)$ 
:k:  &&(77

IxX(( II>%6:nn22$H	 H	V )+//5I$3Id4TT4TV4TUU 	;z!$*G*G*M9 **" 05P:OPP  71+D14B6B 
  ;"DNND3F3N*7:	; ; +; ***./'- 3'D''88 
 =='';;x}}$3x33D$PPPP ''#!,,T2* !006;D$Q!)! 4F;;  ..88BBGGIIK

)FF 	 ..**66tTBC))88E <t <($9&93F;< < < (A 	E#NGd#%dDB4B6Bn47DD		E -1	P)	P!	P 	P" ~02H/99
	-d3 *$)&)* ,<<46::h+? = 
 	
" !N>& &n8 8  Nx J %  		O 	z 
; ;" F< < < < <L* *" 	D,-BCC 	MMFM	s   d+d+<d0d0;&d50d: &e	e5ee7ee# f4"ff+g"f82	g%g' 0	g9g' :ee#	f,f		fff(+f58g	=ggg$ g' '	h!0g=7h!=$h!
debugprimsrO  r  xlavision	torchtext
torchaudio	quantizedc                v    | j                   sy|j                  | j                  v xs |j                         dk(  S )NFzfbgemm::gmm)r)  	namespace+_can_run_unsafe_fallback_allowed_namespacesrN  rP   ra   s     rG   rE  z&FakeTensorMode.can_run_unsafe_fallback	  s:    **
 NNdNNN ,yy{m+	
rF   c                d     g d fd}D cg c]
  } ||       }}|fS c c}w )z
        Checks if the list of tensors are fake tensors.
        If not, try to convert them to fake tensors.
        Returns the original args, kwargs, and a flattened list of (args, kwargs) that are fake tensors.
        c                \   t        | t              s| S 
j                  |       st        j                  j
                  	j                  v r2t        j                        \  }}t        dt        	||             t        j                  
j                  nt        j                  }|s[t        | t              r| j                  
urt        d      t        j                        \  }}t        dt        	||             j!                  
|       }n| }j#                  |       |S )NzECan't call metadata mutating ops on non-Fake Tensor inputs. Found in zMixing fake modes NYIzuPlease convert all Tensors to FakeTensors first or instantiate FakeTensorMode with 'allow_non_fake_inputs'. Found in )r   r   rI  rv   r  r  r  r   r  AssertionErrorr   fake_tensor_tlsrl   r*  r   r   r+  r   )r   r  r  r*  r   rH  r!  rn  r  ra   rP   s        rG   validatezFFakeTensorMode.validate_and_convert_non_fake_tensors.<locals>.validate	  s3   a( ##A&99))TYY6#)#8#8I#NLD&(_`klprvx~`  `A  B 
 'EEM ..(GG &
 -!!Z0Q[[5L,-DEE#)#8#8I#NLD&(BBMdTXZ`BaAbd 
  00q9!((-JrF   )r   rH   rV   Union[T, FakeTensor]rE   )	rP   ra   r!  r  rH  r  r_  validated_argsrn  s	   `````   @rG   rQ  z4FakeTensorMode.validate_and_convert_non_fake_tensors	  s@     35	 	@ 099!(1+99444 :s   -c                `      j                   d dd fd}t        ||      S )NFc                R    t         t              s S t        j                        \  j	                         }|r7t        j                   j                  k(   fd       t        t               S +rj                         S j                   xs       S  S )Nc                 (    dj                    d  S )Nz-FakeTensor is wrapped to wrong device, found z, expected r7  )r  rx  s   rG   r  zZFakeTensorMode.wrap_meta_outputs_with_default_device_logic.<locals>.wrap.<locals>.<lambda>	  s    KAHH:U`an`op rF   )r   r   r   r  rI  rv   _checkr   r   rH   r+  r.  )	rx  rI  r  r!  r   r  ra   r  rP   s	   ` rG   wrapzHFakeTensorMode.wrap_meta_outputs_with_default_device_logic.<locals>.wrap	  s     a($ 224C!* **1-KHH-p Aqz!&) %55dA>>$99a!8=  rF   rx  rH   rV   r  )r3  r-   )	rP   rt  ra   r  r   r  r  r!  r  s	   ` ``` @@@rG   rl  z:FakeTensorMode.wrap_meta_outputs_with_default_device_logic	  s7     ..	 !&	 	B a  rF   r  c                  dd l }ddlm} |4| j                  }| j                  sJ d       | xj                  dz  c_         |j
                   ||d            }|j                  j                  j                  d      }| j                  J | j                  j                  | j                  j                  ||      ||      }|S )Nr   )NestedIntNodez1should only called while FakeTensorMode is activer2   intermediate_offsets_or_lengths)valr   )symr  r   )r@  !torch.nested._internal.nested_intr  r'  r<  r   r7  r   EphemeralSourcer   r"  create_symbol)rP   r  rv   r  r  srcrets          rG   r  z)FakeTensorMode.create_symbolic_nested_int
  s    
 	4C44L##X%XX#%%*%u||M,:;mm""223TU~~)))nn..,, -   / 
 
rF   c                l    t         j                  j                  |j                  v ry|| j                  v S rp   )rv   r  	view_copyr  _cpp_meta_supports_symintr  s     rG   r[  z'FakeTensorMode.cpp_meta_supports_symint,
  s,    99$))+t5555rF   c                    |j                         t        k  xr< t        |       xr. | j                  |       xr |j                  j
                  dk(   S r  )numelCONSTANT_NUMEL_LIMITr   rI  r   r   rH  s     rG   r  zFakeTensorMode.may_turn_const3
  sV    GGI-- ,!!$$,$$Q'', HHMMV++		
rF   c                   t        d |D              }t        |      }|r|j                         rt        |||d      \  }}|j	                         D ]u  \  }	}
|	dk7  s|j                  |	      r|	nd}	| j                  |
      s2|j                  |	      sD|
j                  Q| j                  j                  |
j                         w y y y )Nc              3  8   K   | ]  }|j                   d u  y wrn   r   r  s     rG   r   zAFakeTensorMode.invalidate_written_to_constants.<locals>.<genexpr>B
  r  r  T)r  r  normalize_to_only_use_kwargsinputrP   )
r   r   
is_mutabler!   rs   has_argumentrI  r   r3  r   )rP   ra   rn  r  r  any_constantschema_infor   
new_kwargskr   s              rG   rT  z.FakeTensorMode.invalidate_written_to_constants;
  s     Q;PQQ%d+K224.4TMAz #((* W1w,+*B*B1*EAF$$Q'#..q1

...JJ1::VW	 5<rF   )r%  r   r   r   c                   | j                   }|| j                  }|r|J d       d }| j                  j                  | |||||      S )Nz2cannot set both static_shapes and symbolic_context)r   r   r   r   )r   r%  r3  r+  )rP   r   r%  r   r   r   r   s          rG   r  zFakeTensorMode.from_tensorQ
  sn     )-	  ..M (DCD(I))::- ; 
 	
rF   )r)  r   r*  r   r   r1  r%  rk   r   r   rV   rW   rU   )r   r  rV   zTypeGuard[FakeTensor])rV   r   )rV   rZ   r  )rV   r   )r_  zOptional[type[BaseException]]r`  zOptional[BaseException]ra  zOptional[TracebackType]rV   rW   )rV   r  )
r  r3   ra   r<   r  r  r  r  rV   r  )ra   r<   r  r  r  r  rV   rW   )r  r  r  z?Union[Mapping[str, object], Sequence[object], Iterable[object]]r  r3   rV   rW   )r  r3   r   r  ra   r<   r  r  r  r  rv  r/  rV   rW   )r  r3   r   r  ra   r<   r  r  r  r  rv  r   rV   r  )r  r3   r   r  ra   r<   r  r  r  r  rv  r/  rV   r  )r  r3   rw  r  r   r  ra   r<   r  r  rV   r/  )r  r3   rw  r  r   r  ra   r<   r  r  rV   =Union[Optional[FakeTensor], tuple[Optional[FakeTensor], ...]])rv  r  ra   r<   r  r  r  r  r  r  rV   rW   )
ra   r<   r  r*   r  r  r  r  rV   ztuple[Optional[object], bool])ra   r<   r  r  r  r  r  r  r	  r  rV   zOptional[object])
ra   r<   r  r  r  r  r  r  rV   r/  ra   r<   rV   r   )
ra   r<   r!  r   r  r  rH  r/   rV   z%tuple[list[object], list[FakeTensor]])
rt  r  ra   r<   r  r  r   r4  rV   r,   )r  r  rV   r  r  )
ra   r<   rn  zSequence[FakeTensor]r  r  r  r  rV   rW   )r   r   r%  rk   r   r2  r   r3  r   r   rV   r   )IrB   rC   rD   r!  r]   r"  r#  r   r   r$  rq  rB  r'  r(  rQ   rF  rI  r5  rM  rR  r0   r    r  rZ  r^  r  rf  rh  rk  ry  rn  rs  r  r  r  ru  r  rq  rr  rT  r  r  rt  rt   r  rE  rQ  rl  r  r  r=  r  r  r  as_strided_scatter
as_stridedas_strided_r>  detachview_as_realview_as_complexr  source_Storage_storage_offset(_sparse_coo_tensor_with_dims_and_tensorsr  r[  
lift_freshlift_fresh_copyr  r  rT  r  r  r  s   @rG   r0  r0  V  sQ   :<E7<JL#%0%5NN5 E3N!&$&!! !##"&((
 (,&+(,(, !]D !%]D  $	]D
 &]D &]D  !]D" 
#]D~DA 
 
  
 
 "$'5'7  	
 % 
 $(V(V #V #	V
 
V(   	
 	
  )) ) 	)
 %) 
)V 4 4  4 	 4
 % 4 
 4D(D(D (D %	(D
 
(DT,#,# N,# 	,#
 
,#\CC C 	C
 C %C %C 
C@:: : 	:
 : %: : 
':x11 1 	1
 1 %1 %1 
1f@8@8 -@8 	@8
 @8 @8 
@8D # 	
   
G:#M# # 	#
 # %# 
#R "$'5'7BB B 	B
 %B 
BB__&-_5;_CI_	&_BJ=J= J= 	J=
 J= J= 
J=Xv
v
 v
 	v

 %v
 
v
z 3>	3/	
/5/5 '/5 $	/5
 /5 
//5b.!.! .! $	.!
 .! 
.!b 04,	4 !,

  ""''  

!!$$		//55==!6
 4??22D4H4H4P4PQH
WW  4W 	W
 %W 
W4 )-#'6:

 &	

 !
 4
 
 

rF   c                    t         j                  j                  |j                  v ri t	               5  d fd}|D cg c]
  } ||       }}t
        j                  ||      \  }} ||i |}	d d d        t               |D ]H  }
t        |
t              st        |
      r j                  |
j                         j                         J d fd}t
        j                  |	      S c c}w # 1 sw Y   xY w)Nc                    j                  |       r\t        j                  | | j                        }| j                  r|j                  | j                                | t        |      <   |S | S )Nr7  )rI  rv   
zeros_liker{  r   _coalesced_r  r-  )rx  r   r   	inp_implss     rG   to_real_tensorz+run_fallback_kernel.<locals>.to_real_tensor
  sY    $$Q'&&q?;;OOANN$45%&	"S'"
HrF   c                "   t        |       vr9t        | t              r)t        |       s| j	                         j
                  v rt        | t              r7t        |       v rt        |          S j                  j                  |       S | S rn   )r-  r   r   r   r   _cdatar3  r+  )rx  r   r  orig_not_implemented_exceptionstoragess    rG   map_outz$run_fallback_kernel.<locals>.map_out
  s    a5	!q&!!!$  "))X500a !u	! A'' 66GG	STUUHrF   )rx  rH   rV   zUnion[T, Tensor]r  )rv   r  r  r  r'   r   r  r  r   r   r   addr   r  r-   )r   ra   r  rH  r  r  r_  r  r  rt  rx  r  r  r  s   `   `       @@rG   rF  rF  p
  s     yy*,,I 
 "	 1::1^A&:	:,,Y	Bf$!&!"  &)UH 8a  #Q--/6678   ??7A&&C ;" "s   C:C5#C:5C::Dc                  4    e Zd ZddZ	 	 d	 	 	 	 	 	 	 	 	 ddZy)FakeCopyModec                    || _         y rn   )r   )rP   r   s     rG   rQ   zFakeCopyMode.__init__
  s	    "rF   Nc                   |r|ni }|t         j                  j                  j                  k(  r<t	        |d   t
              sJ  || j                  j                  |d   d      fi |S |t
        j                  k(  rt        |      dk(  rt        |      dk(  sJ t        t
        |d         }t        t        t        t        f   |d         }t        |      |v r|t        |         S | j                  j                  |d      }||t        |      <   |S t         j                  j                         5   ||i |cd d d        S # 1 sw Y   y xY w)Nr   T)r%     r2   )rv   rw   
TensorBaserN  r   r   r   r  __deepcopy__r  r   rq   r   r   r-  DisableTorchFunctionSubclass)rP   ra   r  r  r  r   memor   s           rG   __torch_function__zFakeCopyMode.__torch_function__
  s9    "r 588&&,,,d1gv...**47$*GKQ  V(((t9>c&kQ&666&$q'*FS*_-tAw7D&zT!BvJ''..,,V4,HC"DFJ668 -T,V,- - -s   4EE)r   r0  rV   rW   )rE   N)
ra   r<   r  r  r  r  r  zOptional[Mapping[str, object]]rV   r   )rB   rC   rD   rQ   r  rE   rF   rG   r  r  
  sD    # "$15-- - 	-
 /- 
-rF   r  c                    t        |       dk(  rt        | d   t              sJ | d   j                  j                  rt        j                  d      S | d   j                  S )Nr2   r   r-  )r  r   r   r   rB  rv   r   r{  r  s    rG   _device_handlerr  
  sT     t9>ja*===Aw--||F##Aw"""rF   c                &    t        d | D              S )Nc              3  2   K   | ]  }t        |        y wrn   )rL  r   s     rG   r   z&_check_for_subclass.<locals>.<genexpr>
  s     =a&q)=r   )r   )r  s    rG   rK  rK  
  s    =9===rF   c                    t        | t               xrJ t        | t              xr8 t        |       t        uxr% t        |       t        j
                  j                  uS rn   )r   r   r   r   rv   r  r  r   s    rG   rL  rL  
  sQ    q*%% 	.q&!	.G6!	. G588---	rF   c                d    t        d t        t        | d         j                         D              S )Nc              3  2   K   | ]  }t        |        y wrn   r   r   r,  s     rG   r   z<lambda>.<locals>.<genexpr>
  s      4A4r   r   )r  r   r   r  r  s    rG   r  r  
  s,    e 4VT!W-2244 / rF   c                d    t        d t        t        | d         j                         D              S )Nc              3  2   K   | ]  }t        |        y wrn   r  r  s     rG   r   z<lambda>.<locals>.<genexpr>
  s      6A6r   r   )r  r   r   r  r  s    rG   r  r  
  s,     6VT!W-4466 1 rF   c                V    t        t        t        | d         j                               S )Nr   )r   r   r   r  r  s    rG   r  r    s"    VT!W,,.9 rF   )_device_not_kwarg_ops_is_tensor_constructor_like_tensor_constructorscontains_tensor_typesrZ  rk  rj  r]  c                    t         j                  d       t         j                  dt        j                         t         j                  dt        j                         t        j
                  } | rjt         j                  d       t        d | D              }t        | j                         d       D ]#  \  }}t         j                  d|d	z   | d
|       % y y )NzFakeTensor cache stats:z  cache_hits: %sz  cache_misses: %sz  cache_bypasses:c              3  2   K   | ]  }t        |        y wrn   )r  )r   r  s     rG   r   z#dump_cache_stats.<locals>.<genexpr>!  s     -qCF-r   c                    | d    S rL   rE   )r  s    rG   r  z"dump_cache_stats.<locals>.<lambda>"  s    AaD5 rF   r   z    %-*s %sr2   r  )	r,  infor0  r"  r#  r$  maxsortedrs   )r  widthr  r   s       rG   dump_cache_statsr    s    HH&'HH!:!:;HH!>#>#>?,,H$%-H--8>>+A 	;DAqHH]EAI!Aw:	; rF   c                &   dfd}|j                         dk7  r |d|j                                 t        |j                               D cg c]5  }t        j                  j
                  j                  | j                        7 }}dg|j                         z  }t        |j                               D cg c]	  \  }}||f }	}}|	j                  d        d}
|
}|	D ]P  \  }}||
k7  r' |d|j                   d	|j                          d
       |||<   |
|j                  |   z  }
|||   z  }R | 5  t        j                  |||j                  |j                  |j                        cd d d        S c c}w c c}}w # 1 sw Y   y xY w)Nc                <    t        dj                   d|  d      )NzQpropagate_real_tensors: we cannot infer a Fake kernel (meta kernel) for operator z	 because z>. Please use torch.library.register_fake to add a Fake kernel.)r  r[  )r[   r  s    rG   unsupportedz1_infer_fake_from_real_tensor.<locals>.unsupported)  s1    **,((9VH EKL
 	
rF   r   z'a return has a non-zero storage offset rK  c                    | d   | d    fS r  rE   r  s    rG   r  z._infer_fake_from_real_tensor.<locals>.<lambda>L  s    !qte} rF   r  r2   z(a return was not dense in memory (sizes z	 strides ))r   r  r   )r[   rZ   rV   rW   )r  r  r  rv   r  rf  allocate_sizer   r  r  sortr  r  r   r  r   )r  r  r	  r  r   
fake_shapefake_stridesr  r,  r  expectedfake_strides    `          rG   r  r  &  s   
  A%5h6M6M6O5PQ	
 x||~& 	  ..t~~>J  4(,,.(L&/0A&BCFC3xCGCLL,L-HK 43=:8>>:J)T\TcTcTeSffgh (ShnnS11!JsO34 
 
""??..??

 
5 D
 
s   :E<;F:8FFc                   | j                   J t        j                  |      \  }}t        d |D              st	        d|j
                         |D cg c]  }t        | ||       }}t        j                  ||      S c c}w )Nc              3  P   K   | ]  }t        |t        j                           y wrn   )r   rv   r   r  s     rG   r   z5inferred_fake_kernel_from_real_out.<locals>.<genexpr>k  s     Bqz!U\\*Bs   $&zPpropagate_real_tensors: we don't support operators that return non-Tensors. Got )r   r   r  r   r  r   r  r  )r  r  r	  real_flat_outspecr   fake_flat_outs          rG   rb  rb  b  s     >>%%%
 !--h7M4BMBB  "

|-
 	

 IVV11$A>VMV  55 Ws   B)rs   rH   rV   zdict[T, Literal[True]])rV   z2Generator[Optional[TorchDispatchMode], None, None])r   r   r    list[Union[Tensor, int, SymInt]]rV   r  )r   r  rV   zTypeGuard[Tensor])r   r  rV   zOptional[FakeTensorMode])ra   r<   rV   ztorch._C._SchemaInfor  )r   ztype[T]r   r,   rV   zlist[T])r   r  rV   r   )r   r4  rV   rW   )r   r0  rV   zGenerator[None, None, None])r   r   rV   r  )r   r0  ra   r<   r  r  rH  r,   r  r  rV   r   )r  r  rV   r4  )r  r  rV   r   )r   r  rV   r   rU   )r  r0  r  torch._ops.OpOverloadr	  torch.TensorrV   r  )r  r0  r  r  r	  r   rV   r   )
__future__r   atexitr  r  	functoolsr  r  rV  	threadingr=  typingr   collectionsr   r   r   r   r   r	   r
   r   r   r   typing_extensionsr   r   r   rv   torch._library.utilsr  r  rU  r   r   r   r   torch._C._functorchr   r   "torch._library.fake_class_registryr   torch._loggingr   torch._prims_commonr   torch._subclasses.meta_utilsr   r   r   r   r   torch._utilsr   torch.fx.immutable_collectionsr    torch.fx.operator_schemasr!    torch.multiprocessing.reductionsr"   torch.overridesr#   torch.typesr$   r%   torch.utils._backport_slotsr&   torch.utils._mode_utilsr'   torch.utils._python_dispatchr(   r)   torch.utils._pytreer*   r+   r,   r-   r.   r/   torch.utils._statsr0   torch.utils._tracebackr1   _fake_tensor_utilsr3   r4   r5   collections.abcr6   r7   r8   r9   r  r:   torch._guardsr;   
torch._opsr<   r  r=   r>   	getLoggerrB   r,  _logginggetArtifactLoggerr  
ValueErrorrx  rZ   rA   rm  r  DimList_pytreer   rH   _opsr  r  r  rN   rJ   r  rY   r`   rd   rf   rh   localrj   r  rt   contextmanagerr}   r   r   r   	lru_cacher   r   r   r   r   r?  rI  rP  rR  rZ  r   r  r  r  r  r  r  r  r  r  r0  r  _StoragePointerrF  r  r  rK  rL  r  r   r  r  r  r  r  r  r  r  r  torch._subclasses.fake_implsr  r  r  r  rZ  rk  rj  r]  registerr  r  rb  rE   rF   rG   <module>r.     s   "       	     # ! X X X - !  , , 3 3 T ? , 5  % 9 8 ; - 1 7 / W V $ 4 R R FF#$%Og!..::8EVW	 	 m
			CLzz~~   \   ,   <   <   L  3IOO 3  /& - ->%"02 T. . T	D 	D@
$^ ^B T
 
 @@ @ @,B B>E >EBz4 z4z	 &79LLM  
(% (%  (%V#L 
$ $  $4 
$    
$
" 
"  
" 
$9    
$   (S
& S
l0 ='='
='  =' 	='
 %1=' ='D -$  -F#0> 
IINN!!?	IINN " 
IINN!! $ 
IINN!!)) ,  (	IINN''	IINN$$	IINN%% 	 	 	 	; 	;9

9
39
?K9
9
x6
636?B66}X  )SV3- 	.s   =T> >UUU