a h\@sdZddlZddlmZmZmZmZddlmZddl m Z m Z m Z m Z ddlmZmZddlmZdd lmZmZdd lmZmZdd lmZmZdd lmZmZe rdd lmZddl m!Z!m"Z"GdddeZ#GdddZ$Gddde$Z%Gddde$Z&Gddde$Z'Gddde'Z(Gddde'Z)ddZ*e$dd d!Z+Gd"d#d#e,Z-Gd$d%d%e.Z/Gd&d'd'e/d(Z0d)d*Z1d+d,lm2Z2dS)-a Core variable tracking functionality for Dynamo. This module defines the fundamental classes and systems used to track and manage variables during Dynamo's operation. The module provides: 1. VariableTracker - The base class for tracking variables during compilation 2. MutationType system - Classes for tracking and managing mutations to variables 3. Source type management - Utilities for tracking variable origins and scope 4. Variable state management - Tools for managing variable state and transformations These components form the foundation of Dynamo's variable handling system, enabling accurate tracking and transformation of Python code into optimized computations. N) ItemsViewKeysViewSequence ValuesView)Enum)AnyCallableOptional TYPE_CHECKING)graph_break_hints variables)current_scope_id)raise_observed_exceptionunimplemented_v2) GuardBuilder install_guard) AttrSourceSource)cmp_name_to_op_mappingistype) PyCodegen)InstructionTranslatorInstructionTranslatorBasec@seZdZdZdZdZdS) SourceTypea This Enum divides VariableTracker into 2 cases, depending on the variable it represents: - already existed that Dynamo began tracking while introspection (Existing) - is a new variable that is created during Dynamo introspection (New) In general, we have these invariants: 1. for `VariableTracker` associated with `Existing`, its `source` field must not be None. 2. for `VariableTracker` associated with `New`, most of the time its `source` field is None, except for cases like side effect codegen for `AttributeMutationNew`, during which we generate a `LocalSource('tmp...')` for such variable, to facilitate codegen. rN)__name__ __module__ __qualname____doc__ExistingNewr"r"J/var/www/auris/lib/python3.9/site-packages/torch/_dynamo/variables/base.pyr$src@s eZdZdZeddddZdS) MutationTypez Base class for Variable.mutation_type. It encodes information about 1. The type of mutation Dynamo allows on the variable. 2. Whether the value represented by this variable already existed before Dynamo tracing. N)typreturncCsV|tjurd|_n@|tjur&t|_n,tdd|d|d|ddgtjddS) NrzUnsupported SourceTypezMutationType.__init__  z"Dynamo does not support the type ``z,This branch is not supposed to be reachable.Zgb_typecontextZ explanationhints)rr scoper!rrr Z DYNAMO_BUGselfr%r"r"r#__init__?s    zMutationType.__init__)rrrrrr/r"r"r"r#r$7sr$cs6eZdZdZddfdd ZddZdd ZZS) ValueMutationNewa This case of VariableTracker.mutation_type marker indicates 1. Dynamo allows mutation on the value itself (rather than its attributes). 2. The value is created by the bytecode Dynamo is tracing through. For instance, Dynamo could model a newly created list with this marker, indicating that while we need to model mutations to this list, we don't have to emit bytecode for these mutations if the list doesn't escape into the Python world. Nr&csttjdSN)superr/rr!r. __class__r"r#r/sszValueMutationNew.__init__cCst|Sr2)idr4r"r"r#__hash__vszValueMutationNew.__hash__cCs||uSr2r")r.otherr"r"r#__eq__yszValueMutationNew.__eq__)rrrrr/r8r: __classcell__r"r"r5r#r0gs r0cs2eZdZUdZeed<dedfdd ZZS)ValueMutationExistinga This case of VariableTracker.mutation_type marker indicates 1. Dynamo allows mutation on the value itself (rather than its attributes). 2. The value exists before Dynamo tracing started. For instance, Dynamo could model a pre-existing list with this marker, indicating that if we encounter mutations to this list, we need to buffer and re-apply those mutations after the graph runs, since the list might be used afterwards in Python. is_modifiedF)r=csttj||_dSr2)r3r/rr r=)r.r=r5r"r#r/szValueMutationExisting.__init__)F)rrrrbool__annotations__r/r;r"r"r5r#r<}s r<cs&eZdZdZedfdd ZZS)AttributeMutationz This case of VariableTracker.mutation_type marker indicates that Dynamo allows mutation on the value's attributes. )r%cst|dSr2)r3r/r-r5r"r#r/szAttributeMutation.__init__)rrrrrr/r;r"r"r5r#r@sr@cs eZdZdZfddZZS)AttributeMutationExistinga This case of VariableTracker.mutation_type marker indicates 1. Dynamo allows mutation on the value's attributes. 2. The value exists before Dynamo tracing started. For instance, Dynamo could model a pre-existing object with this marker, indicating that if we encounter mutations to this object, we need to buffer then re-apply those mutations after the graph runs, since the object might be used afterwards in Python. csttjdSr2)r3r/rr r4r5r"r#r/sz"AttributeMutationExisting.__init__)rrrrr/r;r"r"r5r#rAs rAcs,eZdZdZdeedfdd ZZS)AttributeMutationNewa This case of VariableTracker.mutation_type marker indicates 1. Dynamo allows mutation on the value's attributes. 2. The value is created by the bytecode Dynamo is tracing through. For instance, Dynamo could model a newly created object with this marker, indicating that while we need to model mutations to this object, we don't have to emit bytecode for these mutations if the object doesn't escape into the Python world. N) cls_sourcecsttj||_dSr2)r3r/rr!rC)r.rCr5r"r#r/szAttributeMutationNew.__init__)N)rrrrr rr/r;r"r"r5r#rBs rBcCs|dkS)Nrr")scope_idr"r"r#_is_top_level_scopesrE)mcCst}t|rdS|j|kS)NT)rrEr,)rFrDr"r"r#is_side_effect_safesrGcs,eZdZUded<ddfdd ZZS)#AsPythonConstantNotImplementedErrorVariableTrackervt)rJcst|d||_dS)Nz is not a constant)r3r/rJ)r.rJr5r"r#r/sz,AsPythonConstantNotImplementedError.__init__)rrrr?r/r;r"r"r5r#rHs rHcs4eZdZgZedddZddfdd ZZS)VariableTrackerMetar1cCs0t|tjur$|ttjfvr$|}t||S)z-Make isinstance work with LazyVariableTracker)typer LazyVariableTrackerrIrealize__instancecheck__)clsinstancer"r"r#rOs  z%VariableTrackerMeta.__instancecheck__Ncs t|||tj|dSr2)r3r/rKall_subclassesappend)rPnamebasesattrsr5r"r#r/szVariableTrackerMeta.__init__)rrrrRr>rOr/r;r"r"r5r#rKs rKcseZdZdZhdZddZedXedgdfee e e efddddZ e d d d Zd d ZddZddZddZddZddZddZde edddZde ddddZd d!Zd"d#Zd$d%Zd&d'd(d)Zedd d*d+Zedd d,d-Zed d.d/Z ed d0d1Z!dd d2d3Z"ee d d4d5Z#de ddd6d7Z$de%dd8dd9d:d;Z&dd?Z'd@dAZ(dd dBdCZ)dd dDdEZ*dFdGZ+dHdIZ,dJdKZ-dLdMZ.dNdOZ/e0dYdPee e1edQdRdSZ2dddTe1e3ddUfdVdWZ4Z5S)ZrIz Base class for tracked locals and stack values VariableTracker instances are immutable and should be copied in order to change them. Prefer the factory function VariableTracker.build() over VariableTracker.__init__(). > mutation_typevalueZparents_trackerguardssourceZuser_code_variable_namecKs$t|j}|||jfi|S)z)Shallow copy with some (optional) changes)dict__dict__updater6)r.kwargsargsr"r"r#clones  zVariableTracker.cloneN)fnrXcacher&cCs|dur i}t|}||vr dS|||<t|tr||}|||}|j}|jD]\}}||vrZ||||qZnTt|t t fr|D]}||||qn,t|t t j fr|D]}||||qdS)zM Walk value and call fn on all the VariableTracker instances N)r7 isinstancerIunwrap_nonvar_fieldsr\itemsvisitrlisttupler[ collections OrderedDictvalues)rPrarXrbidxZnonvarskeyZsubvaluer"r"r#rgs(   zVariableTracker.visitr1cCs|jjdS)Nz())r6rr4r"r"r#__repr__'szVariableTracker.__repr__cCs.zt|WSty(t|YS0dSr2)repras_python_constantNotImplementedErrorr4r"r"r# debug_repr*s zVariableTracker.debug_reprcCs6zt|WSty0t|ddYn0dS)a Abstract method to be implemented by subclasses of VariableTracker. This method should return the type represented by the instance of the subclass. The purpose is to provide a standardized way to retrieve the Python type information of the variable being tracked. Returns: type: The Python type (such as int, str, list, etc.) of the variable tracked by the subclass. If the type cannot be determined or is not relevant, leaving it undefined or invoking super() is always sound. Note: This is an abstract method and may be overridden in subclasses. Example: class SetVariable(VariableTracker): def python_type(self): return set Raises: NotImplementedError: If the method is not implemented in a subclass. z has no typeN)rLrqrrr4r"r"r# python_type1s zVariableTracker.python_typecCs&z |jWSty YdS0dS)Nz)rtrrrr4r"r"r#python_type_nameNs  z VariableTracker.python_type_namecCs t|dS)z For constantsN)rHr4r"r"r#rqTsz"VariableTracker.as_python_constantc Cs@z |WSty:tdd|d|dgdYn0dS)zcSimilar to as_python_constant(), but add ID_MATCH guards to try to force things to become constantszNot a Python constantzguard_as_python_constant zFailed to convert z into a Python constant.r)N)rqrrrr4r"r"r#guard_as_python_constantXs   z(VariableTracker.guard_as_python_constantcCs(z|WdSty"YdS0dSNTF)rqrrr4r"r"r#is_python_constantds  z"VariableTracker.is_python_constantcCs|jr|j|StdSr2)rZ make_guardrr)r.rar"r"r#ryks zVariableTracker.make_guardr)txrTr&cCstdS)z/getattr(self, name) returning a python constantNrrr.rzrTr"r"r# const_getattrpszVariableTracker.const_getattrcCsR|||}tj|st|jo,t|j|}|rBt|t j tjj ||dS)z,getattr(self, name) returning a new variable)rZ) r}r ConstantVariableZ is_literalrrrZrrryrZCONSTANT_MATCHcreate)r.rzrTrXrZr"r"r# var_getattrts  zVariableTracker.var_getattrcCs(z|WdSty"YdS0dSrw)as_proxyrrr4r"r"r#is_proxy~s  zVariableTracker.is_proxycCstt|dSr2)rrstrr4r"r"r#rszVariableTracker.as_proxycCsFz,|}ddl}t||jjr(|jWSWdSty@YdS0dS)Nr)rZtorch.fxrcZfxZProxynoderr)r.proxyZtorchr"r"r# maybe_fx_nodes zVariableTracker.maybe_fx_noder)codegencCstdSr2r{)r.rr"r"r# reconstructszVariableTracker.reconstructcCstdSr2r{r.rzr"r"r#unpack_var_sequencesz#VariableTracker.unpack_var_sequencecCs ||Sr2)rrr"r"r#force_unpack_var_sequencesz)VariableTracker.force_unpack_var_sequencecCs*z||WdSty$YdS0dSrw)rrrrr"r"r#has_unpack_var_sequences   z'VariableTracker.has_unpack_var_sequencecCs ||Sr2)rrr"r"r#has_force_unpack_var_sequencesz-VariableTracker.has_force_unpack_var_sequencecCs*||sJ||D] }||qdSr2)rr)r.rzravr"r"r#force_apply_to_var_sequencesz+VariableTracker.force_apply_to_var_sequencecCs&tdd|d|dgddS)NzUnsupported inspect callzinspect_parameter_names 0Dynamo does not know how to trace the function `r(r)rrsr4r"r"r#inspect_parameter_namess z'VariableTracker.inspect_parameter_namesc CsFtdd|d|d|dd|jjd|dgtjd dS) NzUnsupported hasattr callzcall_obj_hasattr r'rr(zAvoid calling `hasattr(, z)` in your code.r))rrsr6rr Z SUPPORTABLEr|r"r"r#call_obj_hasattrsz VariableTracker.call_obj_hasattrzdict[str, VariableTracker])rzr_r^r&cCsBtdd|d|d|d|dd|ddgd dS) NzUnsupported function callzcall_function r'rr(Avoid calling `` in your code."Please report an issue to PyTorch.r)r)r.rzr_r^r"r"r# call_functionszVariableTracker.call_functionzlist[VariableTracker])r_r^r&c Cs8|dkr4||r4|s|rJtjt||S|dkrlt|dkrl|drl|sl|||dS|t vrt|dkr|s|d}t |t |st |tj st |tj stjt S|r|r|jj|s|jj|r4tdd|d|d|d|d|d |d d |d gd z tjt |||WSty}z0tt ||tttjj|jgdWYd}~n d}~00d|d|ddg}t |tjr|dvrt |jtttfr|d|dtdd|d|d|d|d|d|d|d dS)N__len__ __getattr__rrz;Builtin `operator.*` comparison with constant `self` failedz call_method r'zFailed to compare z with rzbecause z6 is not a Python constant or its mutation check fails.r))r_r.rr)__iter____next__zConsider moving the creation of dict view object (e.g. `dict.keys()`, `dict.items()`,) to the compiled region, instead of passing it as an input to the compiled region.a Dynamo does not fully support tracing builtin iterators (e.g. `map`, `zip`, `enumerate`) passed in from uncompiled to compiled regions (e.g. `torch.compile(fn)(enumerate(...))`). This can happen unintentionally if a previous graph break happens with a builtin iterator in the local scope.zUnsupported method callz*Dynamo does not know how to trace method `z ` of class `r()rr r~rlenrrxrrqrrcrLZGetAttrVariableNotImplementedoutputZ side_effectsZhas_pending_mutationr Exceptionrrhmapr_ruZUserDefinedObjectVariablerXrrrrS)r.rzrTr_r^r9er+r"r"r# call_methods          zVariableTracker.call_methodcCsdSr2r")r.rTr"r"r# set_name_hint-szVariableTracker.set_name_hintcCs|S)z=Used by LazyVariableTracker to build the real VariableTrackerr"r4r"r"r#rN0szVariableTracker.realizecCs|S)zSUsed by LazyVariableTracker to return the real VariableTracker if it already existsr"r4r"r"r#rd4szVariableTracker.unwrapcCsdS)z:Used by LazyVariableTracker to indicate an unrealized nodeTr"r4r"r"r# is_realized8szVariableTracker.is_realizedcCs*tdd|dd|dgtjddS)NzUnsupported next() callznext()z@Dynamo does not know how to trace calling `next()` on variable `z`.r))rr Z USER_ERRORrr"r"r# next_variable<s   zVariableTracker.next_variablecCs|jo||Sr2)Zstrict_checks_fnrr"r"r#is_strict_modeDszVariableTracker.is_strict_modecCs | S)z0Whether Dynamo allows mutation on this variable.) is_immutabler4r"r"r# is_mutableGszVariableTracker.is_mutablecCs |jduS)z.Whether Dynamo bans mutation on this variable.N)rWr4r"r"r#rKszVariableTracker.is_immutabler)rzrXrZr&cCs(|durtj||Stj||SdS)z=Create a new VariableTracker from a value and optional SourceN)builderZSourcelessBuilderrr rM)rzrXrZr"r"r#buildOszVariableTracker.build)rZrW)rZrWr&cs\t||_||_|durXt|ttfr:|dusXJnt|ttfsLJ|dusXJdSr2) r3r/rZrWrcr0rBr<rA)r.rZrWr5r"r#r/[s zVariableTracker.__init__)N)N)6rrrrrer` classmethodrrr r[intrgrrorsrtrurqrvrxryr}rrrrrrhrrr>rrrrrrrrrrNrdrrrrr staticmethodrrr$r/r;r"r"r5r#rIs   !        SrI) metaclasscGsDt|dkr0|\}t|tr$t|St|jSndtt|SdS)Nrr') rrcrIrrLrjoinrtypestr)objsobjr"r"r#rws    rr)r)3rrjcollections.abcrrrrenumrtypingrrr r r r rexcrrrYrrrZrrutilsrrrrZsymbolic_convertrrrr$r0r<r@rArBrErGrrrHrLrKrIrrr"r"r"r#s<   0