
    ^j:                     4   d dl Z d dlmZ d dlmZ d dlZd dlZd dlmZ d dl	m
Z
 d dlmZ ddlmZ dd	lmZ d
edefdZdeej&                     defdZdedeeef   dee   deeej&                  f   deeeej&                     f   ddfdZdeddfdZ ed       G d d             Zdede
ej4                  j6                     fdZdej4                  j6                  de
ej4                  j6                     fdZ G d d      Z G d  d!      Zdeddfd"Z y)#    N)	dataclass)Any)map_arg)
OrderedSet)ValueRanges   )LoopBody)dominated_nodesvalreturnc                    t        | dd      ryt        | t        j                        r=| j                  sJ | j
                  s| j                  rt        |       } nt        |       } t        | t              r| dk  xr | dk\  S t        | t              rCt        j                  t        j                        }| |j                  k  xr | |j                  k\  S t        d|        )N
is_BooleanFTi   i   zUnexpected value )getattr
isinstancesympyExpr	is_number
is_Integerr   intfloattorchiinfoint32maxmin	TypeError)r   r   s     l/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/_inductor/optimize_indexing.pyval_expressable_in_32_bitsr      s    sL%(#uzz"}}}>>S^^c(C*C #uu~1#/1#sEKK(eii4C599$44
'u-
..    rangec                 Z    t        | j                        xr t        | j                        S N)r   lowerupper)r    s    r   range_expressable_in_32_bitsr%   &   s'    %ekk2 7Q8 r   nodeboundsindirect_varsindicesreplacement_valsc                    dt         dt        fd}t        | g|      D ].  }|j                  dv rt	        |j                  t
              rd|j                  v rt        |j                  t        d      d        }||   }|j                         D ]  \  }	}
||
j                  v s||	   }t        j                  |j                        st        j                  |j                        r  y t        t        j                      t        |j                        t        |j                              }t#        |      r  y  t#        ||         r/ y  t%        | j&                        }t(        j*                  |d<   t-        |      | _        y )Nr&   r   c                     | j                   dk(  xr> | j                  d   t        j                  t        j                  t        j
                  fv S )Nto_dtype   )targetargsr   r   float32float64)r&   s    r   skip_filterz,try_to_reduce_precision.<locals>.skip_filter6   sA    {{j( 
TYYq\KKMMMM>
 .
 	
r   )storeoutputset_indirectr.   )r   boolr
   r/   r   strr   lenitemsfree_symbolsmathisinfr#   r$   r   r   r   r%   listr0   r   r   tuple)r&   r'   r(   r)   r*   r3   	dominatedidxindirect_varindexexpr	index_valindex_val_intr0   s                 r   try_to_reduce_precisionrG   ,   sL   
# 
$ 
 %dV[9 	22i&&,9CSCS1Si&&s>':'<=>C(-L  '}} t4#4#44 0 7Izz)//2djj6Q %0

$;IOO,c)//.B%M 8F!$ ,F9,=>9< 		?DkkDGdDIr   	loop_bodyc                 p   | j                         }| j                         D cg c]A  }|j                  dk(  r0|j                  d   t        j
                  k(  r||j                  vr|C }}|sy|j                         }|D ]/  }t        ||| j                  | j                  |j                         1 yc c}w )z|
    Performs Value Range Analysis on LoopBody's fx graph to reduce precision of
    intermediaries from int64 to int32
    r-   r.   N)r'   	get_nodesr/   r0   r   int64unbounded_vars
get_boundsrG   r(   indexing_exprsr*   )rH   bvr&   int64_dtype_nodesr'   s        r   !indexing_dtype_strength_reductionrQ   c   s    
 
			B '')KK:%		!+B--- 	  ]]_F " 
##$$	

!s   AB3T)frozenc                   V    e Zd ZU dZeedf   ed<   dZeedf   ed<   dZeedf   ed<   y)_ValueUseRule .value_inputsvalue_sinksindexing_inputsN)	__name__
__module____qualname__rV   r?   r   __annotations__rW   rX   rU   r   r   rT   rT      s:     %'L%S/&#%KsCx%')OU38_)r   rT   argc                     t               dt        j                  j                  dt        j                  j                  ffd}t	        | |       S )Nr&   r   c                 *    j                  |        | S r"   )add)r&   nodess    r   add_nodez#_collect_fx_nodes.<locals>.add_node   s    		$r   )r   r   fxNoder   )r]   rb   ra   s     @r   _collect_fx_nodesre      s>    '1|Euxx}}   CLr   c                    t        | j                        }| j                  dk(  r[| j                  rOt	        | j                  d   t
        j                  j                        r|j                  | j                  d          |S )Ncall_methodr   )	r   all_input_nodesopr0   r   r   rc   rd   discard)r&   inputss     r   _collect_input_nodesrl      sX    ,,-F= IItyy|UXX]]3tyy|$Mr   c                   B   e Zd Zededededz  fd       Zdedej                  defdZ
ded	edefd
Z	 d7dedej                  dededef
dZdedej                  dedefdZdej                   dej                   dededef
dZdedededeeef   def
dZdeej                   df   deedf   dededef
dZ	 d7deej                   df   dedeedf   dz  defdZ	 	 d8dedeeej                  ej                  ej                  f   dedej                   d ed!eeej                  f   dz  d"edz  defd#Z	 d9d$ed%ej                  d&ed'edef
d(Zd)ej                  d%ej                  d*ed+edef
d,Zd-ed.ed/edefd0Zd-ed/edefd1Zd2edefd3Zd4ed5edefd6Zy):_ValueUseRulesr0   kwargsr   Nc                       y r"   rU   )r0   ro   s     r   default_rulez_ValueUseRules.default_rule   s    r   namerC   c                     t        |f      S N)rX   rT   )selfrr   rC   s      r   loadz_ValueUseRules.load   s    eX66r   offsetc                     t        |f      S rt   ru   )rv   rr   rx   s      r   	load_seedz_ValueUseRules.load_seed   s    fY77r   valuemodec                      t        |f|f      S N)rW   rX   ru   )rv   rr   rC   r{   r|   s        r   r4   z_ValueUseRules.store   s     "H
 	
r   c                      t        |f|f      S r~   ru   )rv   rr   rC   r{   s       r   store_reductionz_ValueUseRules.store_reduction   s     "H
 	
r   dtype	src_dtypereduction_typec                     t        |f      S N)rW   ru   )rv   r   r   r   r{   s        r   	reductionz_ValueUseRules.reduction        %22r   
extra_metac                     t        |f      S r   ru   )rv   rr   r   r{   r   s        r   partial_accumulatez!_ValueUseRules.partial_accumulate   r   r   dtypes.valuesstable
descendingc                     t        |f      S r   ru   )rv   r   r   r   r   s        r   sortz_ValueUseRules.sort   s     &33r   combine_fn_or_valuesc                 $    ||}t        |f      S r   ru   )rv   r   r   r   s       r   scanz_ValueUseRules.scan   s     >)F&33r   
boundariesboundary_indicesindexing_dtyperightsortersorter_indicesc                 &    t        |f||||f      S N)rV   rX   ru   )rv   r   r   r   r   r   r   r   s           r   	bucketizez_ValueUseRules.bucketize   s#      ')96>R
 	
r   xsizecheckwrap_negc                     t        ||f      S rt   ru   )rv   r   r   r   r   s        r   indirect_indexingz _ValueUseRules.indirect_indexing   s     aY77r   rD   r#   r$   c                     t        ||f      S rt   ru   )rv   rD   r   r#   r$   s        r   check_boundsz_ValueUseRules.check_bounds   s     dD\::r   maskbodyotherc                      t        |f|f      S r   ru   )rv   r   r   r   s       r   maskedz_ValueUseRules.masked      5(TGLLr   c                      t        |f|f      S r   ru   )rv   r   r   s      r   masked_subblockz_ValueUseRules.masked_subblock  r   r   new_varc                     t        |f      S rt   ru   )rv   r   s     r   r6   z_ValueUseRules.set_indirect
  s    gZ88r   condmsgc                     t        |f      S rt   ru   )rv   r   r   s      r   device_assert_asyncz"_ValueUseRules.device_assert_async  s    dW55r   r"   )NN)TT)rY   rZ   r[   staticmethodr   rT   rq   r8   r   r   rw   r   rz   r4   r   r   r   r   dictr   r?   r7   r   r   r   r   r   r   r   r6   r   rU   r   r   rn   rn      sJ   C 3 =43G  7 7UZZ 7M 78c 83 8= 8 



 zz

 	


 

 




 %


36
	
3{{3 ;;3 	3
 3 
333 3 	3
 cN3 
34ekk3&'4 c3h4 	4
 4 
4 *.	4ekk3&'4 "4 c3h$&	4
 
4" 15%)

 #uzz5::uzzAB
 	

 
 
 c5::o&-
 d

 

  NR88!JJ8/38FJ8	8
;JJ;&+jj;9=;FJ;	;
M3 Mc M# M- MMC M M M9C 9M 96 6# 6- 6r   rn   c                      e Zd ZdeddfdZdefdZdefdZddZddZ	defd	Z
d
ej                  j                  dedz  fdZd
ej                  j                  deej                  j                     fdZd
ej                  j                  deej                  j                     fdZdej                  j&                  ddfdZy)_ValueUseAnalysisrH   r   Nc                 n   || _         t               | _        |j                  j                  | _        t        |di       | _        t        |dd      | _        | j
                  gd | j                  j                         D        | _
        | j                          t               | _        g | _        i | _        y )N	subblocksr(   rU   c              3   4   K   | ]  }|j                     y wr"   )graph).0blocks     r   	<genexpr>z-_ValueUseAnalysis.__init__.<locals>.<genexpr>  s     ?eekk?s   )rH   rn   rules
root_blockr   
root_graphr   r   r(   r   graphsinstall_call_module_rulesr   value_reachableworklistindirect_inputs)rv   rH   s     r   __init__z_ValueUseAnalysis.__init__  s    "#%
#..44 K<$YDOO
?t~~'<'<'>?
 	&&(:D,DFOQr   c                 d    | j                         sy| j                          | j                         S )NF)has_index_exprseed_value_reachable_nodespropagate_value_reachabilityrv   s    r   runz_ValueUseAnalysis.run"  s,    ""$'')0022r   c                 :    t        d | j                  D              S )Nc              3   D   K   | ]  }|j                  d dd        yw)rg   
index_exprF)ri   r/   r   N)
find_nodes)r   r   s     r   r   z3_ValueUseAnalysis.has_index_expr.<locals>.<genexpr>*  s*      
 lO
s    )anyr   r   s    r   r   z _ValueUseAnalysis.has_index_expr)  s      

 
 	
r   c                 t   | j                   D ](  }|j                  dd      D ]  }t        |j                  t              s|j                  | j
                  v r6t        | j                  |j                  | j                  j                         m|j                  j                  d      r6t        | j                  |j                  | j                  j                         |j                  j                  d      st        | j                  |j                  | j                  j                          + y )Ncall_moduleFri   r   r   r6   )r   r   r   r/   r8   r   setattrr   r   
startswithr   r6   )rv   r   r&   s      r   r   z+_ValueUseAnalysis.install_call_module_rules/  s    [[ 		NE((M(F N!$++s3;;$..0DJJTZZ5O5OP[[++F3DJJTZZ__E[[++N;DJJTZZ5L5LMN		Nr   c                    | j                  | j                         | j                  D ]  }|j                  D ]  }|j                  dk(  r|j                  dk(  r~t        |j                  t              rd|j                  j                  d      rIt        |j                  t        d      d        }||j                  f| j                  | j                  |   <   | j                  |      D ]  }| j                  j!                  ||f       !   y )Nr5   r   r6   )_enqueue_graph_outputr   r   ra   ri   r   r/   r8   r   r   r9   r0   r   r(   value_sink_nodesr   append)rv   r   r&   rA   	sink_nodes        r   r   z,_ValueUseAnalysis.seed_value_reachable_nodes;  s    ""4??3[[ 	=E =77h&GG},"4;;4..~>dkk#n*=*?@ACEJDIIDVD((););C)@A!%!6!6t!< =IMM((%);<==	=r   c                    
 d} j                   rɉ j                   j                         \  }}| j                  v r9 j                  j                  |       |j                  dk(  r	d|_        d}|j
                  dk(  rdt        |j                  t              rJ|j                   j                  v r2 j                   j                  |j                     j                         |j
                  dk(  r|j                  dk(  r|j                  d   }t        |t              sJ  j                  j                  |   }t        |t        j                        rD|j                   D ]5  } j"                  j%                  |      }|!|\  
}t'        |
 fd       7  j)                  |      D ]  }	 j                   j+                  ||	f       !  j                   r|S )	NFr   
value_exprTr   	get_indexr   c                 >    j                   j                  | f      S r"   r   r   )nigrv   s    r   <lambda>z@_ValueUseAnalysis.propagate_value_reachability.<locals>.<lambda>g  s    $--2F2FAw2O r   )r   popr   r`   r/   ri   r   r8   r   r   r   r0   rH   rN   r   r   r;   r   getr   value_input_nodesr   )rv   changedr   r&   
index_namerD   symbolindirect_inputia
input_noder   s   `         @r   r   z._ValueUseAnalysis.propagate_value_reachabilityK  s   mm--++-KE4t+++  $$T*{{l** =(t{{C0KK4>>1**4>>$+++F+L+LMww-'DKK;,F!YYq\
!*c222~~44Z@dEJJ/"&"3"3 Q)-)=)=)A)A&)I)5%3FB#B(OP	Q #44T: :
$$eZ%89:9 mm> r   r&   c                    |j                   dk(  rnt        |j                  t              rTt	        | j
                  |j                  | j
                  j                        } ||j                  dd  i |j                  S |j                   dk(  rkt        |j                  t              rQt	        | j
                  |j                  | j
                  j                        } ||j                  i |j                  S y )Nrg   r   r   )	ri   r   r/   r8   r   r   rq   r0   ro   )rv   r&   rule_fns      r   rule_for_nodez_ValueUseAnalysis.rule_for_noden  s    77m#
4;;(Ddjj$++tzz7N7NOGDIIabM9T[[9977m#
4;;(Ddjj$++tzz7N7NOGDII555r   c                     | j                  |      }|t        |      S t        |j                        t        |j                        z  S r"   )r   rl   re   rV   rW   rv   r&   rules      r   r   z#_ValueUseAnalysis.value_input_nodesw  sK    !!$'<'-- !2!236G7
 
 	
r   c                 f    | j                  |      }|rt        |j                        S t               S r"   )r   re   rW   r   r   s      r   r   z"_ValueUseAnalysis.value_sink_nodes  s-    !!$'6: !1!12L
Lr   r   c                      j                  dd      }t        |      dk(  sJ t        |d   j                   fd       y )Nr5   Fr   r   r   c                 >    j                   j                  | f      S r"   r   )r   r   rv   s    r   r   z9_ValueUseAnalysis._enqueue_graph_output.<locals>.<lambda>  s    0D0DeQZ0P r   )r   r9   r   r0   )rv   r   output_nodess   `` r   r   z'_ValueUseAnalysis._enqueue_graph_output  s@    ''8%'@< A%%%Q$$&PQr   )r   N)rY   rZ   r[   r	   r   r7   r   r   r   r   r   r   rc   rd   rT   r   r   r   r   Graphr   rU   r   r   r   r     s    R( Rt R 3T 3
 

N= !d !F%((-- MD4H 
ehhmm 

588==8Q 
MUXX]] Mz%((--7P MR588>> Rd Rr   r   c                     t        |       j                         r?t        j                  j	                  |        t        j
                  j	                  |        yy)av  
    Rewrite ``index_expr`` nodes that participate in value computation to
    ``value_expr``, so codegen can honor the requested dtype instead of
    narrowing to the kernel's indexing dtype.

    Classification: walk backward from value sinks (store value, reduction,
    output). Indexing inputs to ops such as ``load``, ``store``,
    ``check_bounds``, and ``set_indirect`` do not receive value demand. Any
    ``index_expr`` reachable from a value sink is converted in-place to
    ``value_expr``. Indirect indexing is handled by following value-reachable
    ``get_index`` expressions through any referenced ``indirect*`` symbols back
    to the corresponding ``set_indirect*`` input.

    Mixed-use policy: if the same ``index_expr`` feeds both an indexing use and
    a value use, rewrite it in-place to ``value_expr``. This is conservative and
    correct because the indexing path may compute at a wider dtype than needed,
    but the value path cannot lose precision. Cloning would preserve the
    narrower indexing path, but the mixed-use case is rare and the simpler
    in-place rewrite avoids extra CSE/register pressure.
    N)r   r   r	   rJ   clear_cacher'   )rH   s    r    convert_index_expr_to_value_exprr     s@    * #'')&&y1##I. *r   )!r<   dataclassesr   typingr   r   r   torch.fx.noder   torch.utils._ordered_setr   torch.utils._sympy.value_rangesr   rH   r	   utilsr
   r7   r   r   r%   r   r>   rG   rQ   rT   rc   rd   re   rl   rn   r   r   rU   r   r   <module>r     se    !    ! / 7  "/C /D /,EJJ(? D 4
4cN4 94 #uzz/"	4
 3EJJ 7784 
4n
 
d 
B $	* 	* 	*3 :ehhmm#< uxx}} EHHMM1J g6 g6TuR uRp/ /T /r   