^jLddlmZddlZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z mZmZerdd lmZdd lmZdd lmZdd lmZGd dZGddeeZGddeZGddZ ddZddZey)) annotationsN)Any TYPE_CHECKING)config)is_function_or_wrapper)SourceLocationVariableTrackerVariableTrackerMeta)Callable)Self)InstructionTranslatorBaseSymNodeVariablec eZdZdZddZddZy) LazyCachez+Container to cache the real VariableTrackerct|ts |s td||_||_d|_d|_d|_y)Nz9source is required for non-LazySymNodeFormatString values) isinstanceLazySymNodeFormatStringAssertionErrorvaluesource name_hintsource_locationvt)selfrrs g/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/_dynamo/variables/lazy.py__init__zLazyCache.__init__sF%!89$O  %)6:*.c\|j tdddlm}ddlm}|j }t|jtr,|jj||j|_n3|j||jd|j|_|j%|jj|j|j ;|jj %|jj#|j |`|` |`|`y)Nz0LazyCache.realize() called but vt is already setr)InstructionTranslatorr )builderFallow_lazy_constant)rrsymbolic_convertr"r# current_txrrrSourcelessBuildercreateVariableBuilderrr set_name_hintrset_source_location)rr"r#txs rrealizezLazyCache.realize$s 77  !ST T< " - - / djj"9 ://66r4::FDG g--DKKU.jjDG >> % GG ! !$.. 1    +0G0G0O GG ' '(<(< = J K N  r N)rrrrreturnNoner0r1)__name__ __module__ __qualname____doc__rr/r rrrs5 /!r rc.eZdZdZdZdhej Zedd ddZdfd Z ddZ dd Z dd Z dd Z d d Zd!d Zd"dZd#dZd$dZd%dZd&dZd'dZej,ZeZe d(dd d)dZddZd"dZd"dZxZS)*LazyVariableTrackera A structure that defers the creation of the actual VariableTracker for a given underlying value until it is accessed. The `realize` function invokes VariableTracker.build() to produce the real object. Once a LazyVariableTracker has been realized, internal bookkeeping will prevent double realization. This object should be utilized for processing containers, or objects that reference other objects where we may not want to take on creating all the VariableTrackers right away. T_cacheN)r.c 4t|tjvrtj||fi|S|M|K|sI|jj }|j |}||Stt|||}|||<|Stt||fd|i|S)N)rr) typeLazyConstantVariablesupported_typesr*outputvariable_tracker_cachegetr9r)rrr.optionscachecachedrs rr*zLazyVariableTracker.createTs ;.>> >'..ufHH H >f0II44EYYv&F! $Yuf%=fMBE&MI"9UF#;VFVgVVr c t|ts!tdt|jt |di|||_y)Nz)_cache must be a LazyCache instance, got r7)rrrr<r3superrr:rr:kwargs __class__s rrzLazyVariableTracker.__init__ksH&), ;DL> ! KK   !{{~~%$%IJJ{{~~r cJtj||jS)zNCheck isinstance after realizing, used by ImplicitRealizingVariableTrackerMeta)r<__instancecheck__r/)rclss rlazy_isinstancez#LazyVariableTracker.lazy_isinstance{s%%c4<<>::r c|jr7|jj td|jjS|S)z4Return the real VariableTracker if it already existsz*is_realized() returned True but vt is None) is_realizedr:rrrKs runwrapzLazyVariableTracker.unwraps;    {{~~%$%QRR;;>> ! r c2|jjduSN)r:rrKs rrQzLazyVariableTracker.is_realizeds{{~~T))r c  |jd|j|jur td|jd|j|jur|j t j |jfi|S)Nr:z8cannot clone LazyVariableTracker with a different _cacher)rAr:rrr/r clonerR)rrHs rrVzLazyVariableTracker.cloneso ::h ,DKK ? J  ::h ,DKK ? LLN$$T[[]=f==r cv|jr tdt|jjS)Nz=peek_type() called on an already realized LazyVariableTracker)rQrr<r:rrKs r peek_typezLazyVariableTracker.peek_types5     O DKK%%&&r cd|jr td|jjS)Nz>peek_value() called on an already realized LazyVariableTrackerrQrr:rrKs r peek_valuezLazyVariableTracker.peek_values0     P {{   r c|jr&|jjj|y||j_yrT)rQr:rr,r)rnames rr,z!LazyVariableTracker.set_name_hints0     KKNN ( ( .$(DKK !r c||_|jr&|jjj |y||j_yrT)rrQr:rr-)rrs rr-z'LazyVariableTracker.set_source_locations8.     KKNN . . ?*9DKK 'r cd}|jr"|dt|jdz }|S|d|jdz }|S)NzLazyVariableTracker(z realized: )z unrealized: )rQreprrRrX)r variable_infos r__str__zLazyVariableTracker.__str__s].     z$t{{}*=)>a@ @M |DNN,<+=Q? ?Mr c6t|j|SrTgetattrr/)ritems r __getattr__zLazyVariableTracker.__getattr__st||~t,,r ctS)aReturn the VariableTracker type to use for builtin handler dispatch. For regular LazyVariableTracker (not LazyConstantVariable), we return LazyVariableTracker itself so that _make_handler knows it needs to realize the arguments before calling the handler. LazyConstantVariable overrides this to return ConstantVariable since it can stay lazy. )r9rKs rget_handler_type_for_dispatchz1LazyVariableTracker.get_handler_type_for_dispatchs #"r Fr$c  it|}|vr|dSt|}t|tr=xrt |t }|r|}nj |j}nt|trH|}||f|<|j}|j} |D]!} | | vsj || || <#n|tur"|D cgc]} j | }} nx|turtfd|D}nY|ttjfvr?t|j!D cic]\} } | j | }} } n|}||f|<|Scc} wcc} } w)zP Walk an object and realize all LazyVariableTrackers inside it. rr$c3FK|]}j|yw)r$N) realize_all).0vr%rCrNs r z2LazyVariableTracker.realize_all..s)5>QRs!)idr< issubclassr9rr=rmr/r __dict___nonvar_fieldslisttupledict collections OrderedDictitems) rNrrCr%idx value_cls keep_lazyresult value_dictnonvarskeyroks ` `` rrmzLazyVariableTracker.realize_alls =Ei %<:a= K i!4 5+W 5BV0WIMMOU@S) ? 3F %E#JJ**G! g%&)oo"3DW'6'JsO  $ 5>QRF% F4!8!89 9!/Aq3??1eAT?UUF Fe_c  's E: E?cdd|jr td|jj}t |t rt fd|DS|S)Nc|tj|xs&tt|txs t |SrT)inspect isbuiltinrrr<r)rs r_helperz5LazyVariableTracker.is_hashable_lazy.._helper s7!!%(1d5k401)%0 r z?is_hashable() called on an already realized LazyVariableTrackerc3.K|] }|ywrTr7)rnrors rrpz7LazyVariableTracker.is_hashable_lazy..s1awqz1s)rrr0bool)rQrr:rrrvall)rrrs @ris_hashable_lazyz$LazyVariableTracker.is_hashable_lazys\      Q  !! eU #1511 1u~r cd|jr td|jjS)NzBoriginal_value() called on an already realized LazyVariableTrackerrZrKs roriginal_valuez"LazyVariableTracker.original_values0     T {{   r cd|jr td|jjS)NzCoriginal_source() called on an already realized LazyVariableTracker)rQrr:rrKs roriginal_sourcez#LazyVariableTracker.original_source#s0     U {{!!!r ) rrrrr.z InstructionTranslatorBase | NonerBrr0r r:rrHrr0r1r0r rNr<r0r)r0zVariableTracker | Selfr0r)rHrr0r )r0z type[Any])r0r)r]strr0r1)rr r0r1r0r)rgrr0rr0r<rT)rrrCz!dict[int, tuple[Any, Any]] | Noner%rr0r)r3r4r5r6_no_implicit_realizer rt staticmethodr*rr/rOrRrQrVrXr[r,r-rcrhrjvisit__repr__ classmethodrmrrr __classcell__rIs@rr9r9Bs  @!?!?@N 04 WWW - W  W  WW,;*>'!) :-#  ! !EH48; %* ;;1; " ; ;;z*!"r r9) metaclassceZdZdZeeeefZdddhe jZ e ddZ dfd Z ddZdfd Zdfd Zdd Zdd Zdd Zdd Zdfd ZxZS)r=az A lazy variable tracker for constants (int, float, bool, str) that defers guarding until the value is actually used in a way that requires it. This allows constants that are just passed through (e.g., returned without being used in control flow or math) to avoid unnecessary recompilation when their values change. Guards are installed lazily: - TYPE_MATCH guard is installed when type-based methods (python_type, is_tensor, lazy_isinstance) are called - CONSTANT_MATCH guard is installed on full realization (e.g., used in control flow or math), which subsumes any TYPE_MATCH guard _type_guard_installed_type_guard_ref _handler_typec ddlm}ddlm}t |t j vr"tdt |jd| td||r|j|fd|i|St t||fd|i|S) Nr)is_constant_sourcer ConstantVariablezunsupported type z for LazyConstantVariablez0source must not be None for LazyConstantVariabler) rrconstantrr<r=r>rr3r*r)rrrBrrs rr*zLazyConstantVariable.createDs 0. ;2BB B #DK$8$8#99RS  > !ST T f %*#**5KK7K K#IeV$<WVWwWWr c Pt||fi|d|_d|_d|_yNF)rFrrrrrGs rrzLazyConstantVariable.__init__[s- *6*%*"$(*.r c|js|jryddlm}m}|j t d|j j|j}||d|_||_ y)zCInstall TYPE_MATCH guard if not already installed and not realized.Nr GuardBuilder install_guardz2source must not be None when installing type guardT) rrQguardsrrrr make_guard TYPE_MATCHr)rrrguards r_ensure_type_guardz'LazyConstantVariable._ensure_type_guardasd  % %)9)9); 8 ;;  !UV V &&|'>'>?e%)"$r c|jrt| Sddlm}ddlm}m}ddlm }|j tdt| }t||r|jP|j}|jj j"j%|jd|_ ||jj'|j(|S) z/Force construction of the real VariableTracker.r)TracingContextrrr rNz;source must not be None when realizing LazyConstantVariable)rQrFr/ torch._guardsrrrrrrrrrrrAguards_context dynamo_guardsinnerdiscardrCONSTANT_MATCH)rrrrrr~tracing_contextrIs rr/zLazyConstantVariable.realizeos    7?$ $08. ;;  M " f. /##/"0"4"4"6..<<BBJJ(((,$ $++001L1LM N r c|jrt| S|j|j S)z6Return the Python type without triggering realization.)rQrF python_typerrX)rrIs rrz LazyConstantVariable.python_types6    7&( ( !~~r c$|jy)z&Primitive constants are never tensors.FrrKs r is_tensorzLazyConstantVariable.is_tensors !r c$|jyrrrKs ris_constant_nonez%LazyConstantVariable.is_constant_nones !r cZ|jrt|jS|j}tj s!|t urt|jStjs!|turt|jS|jy)aCheck if we need to realize to determine the VariableTracker type. Returns None if we can determine the type without realization (and installs TYPE_MATCH guard). Returns the realized type if realization was needed. With specialize_int=False or specialize_float=False, ints/floats may become either ConstantVariable or SymNodeVariable, so we must realize to know. For bool/str, we always know it will be ConstantVariable. N) rQr<r/rXrspecialize_intintspecialize_floatfloatr)r value_types r_maybe_realize_for_typez,LazyConstantVariable._maybe_realize_for_types     ' '^^% $$s): ' '&&:+> ' ' !r c|j |jSddlm}|j}||n||_|jS)zReturn the VariableTracker type to use for builtin handler dispatch. This allows builtins like isinstance() and type() to find the correct handler without triggering full realization of the lazy constant. r r)rrrr)rr realized_types rrjz2LazyConstantVariable.get_handler_type_for_dispatchsN    )%% %.446 *6Mr9rtrr*rrr/rrrrrjrOrrs@rr=r=,s E4-O  + + NXXXX  XX,/ %<  6""11r r=c(eZdZ ddZddZy)rcrddlm}||_|jd|j zdz|_y)Nr rz{:})rr sym_node_varr*as_python_constantfmt_var)rsym_node_variable fmt_spec_varrs rrz LazySymNodeFormatString.__init__s7 /-'.. <224 4s :  r ctj|jjt|jj SrT)rformatrrr evaluate_exprrKs rrz LazySymNodeFormatString.__repr__s:zz LL + + - !!//1 2  r N)rrrr r0r1r)r3r4r5rrr7r rrrs$ !0 @O   r rcptjtt dfd }|S)NcDt|j|i|SrTre)rargsrHr]s rrealize_and_forwardz8_create_realize_and_forward..realize_and_forwards$-wt||~t,d=f==r )rr9rrrHrr0r) functoolswrapsrfr )r]rs` r_create_realize_and_forwardrsO__W_d34>!>*->9<> >5> r ctjjD]>\}}|tjvst |s%t t|t |@yrT)r rsrzr9callablesetattrr)r]rs r _populatersO&//557V e *33 3+T3Nt3TUVr )r]rr0z.Callable[[LazyVariableTracker, Any, Any], Any]r2) __future__rrxrrtypingrrr'rutilsrbaser r r collections.abcr typing_extensionsrr&rrrrr9r=rrrr7r rrs"%*FF(&<'*!*!Zg"/5Hg"Tz1.z1z  $   3 V r