o ei@s,UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZddlmZmZmZmZmZmZmZddl m!Z!ddl"Z"ddl#Z"ddl$m%Z%m&Z&ddl'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1dd l2m3Z3d dl4m5Z5m6Z6m7Z7mZ8m9Z9m:Z:d dl;mZ>m?Z?d dl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOd dlPmPZPd dlQmRZRd dl6mSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[d dl\m]Z]d dl^m_Z_m`Z`d dlambZbmcZcmdZdd dlemfZfmgZgmhZhmiZimjZjd dlkmlZlmmZmd dlnmoZompZpmqZqmrZrd dlsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{d dl9m|Z|m}Z}d dl~mZmZmZmZmZmZmZmZmZd dlmZmZmZd dlmZmZmZd dlmZd d lmZmZd d!lmZmZmZmZd d"lmZmZd d#lmZmZmZmZmZmZmZd d$lmZd d%lmZd d&lmZmZmZmZmZmZd d'lmZmZmZmZmZmZmZd d(lmZmZd d)lmZd d*lmZmZd d+lmZmZd d,lmZmZmZmZmZer2dd-lmZmZmZdd.lmZd d/lmZeeѡZe"jӠed0Ze"jӠed1Ze"jӠed2Ze"jӠed3Ze١Zd4d5eۡDZd6ed7<eejރjZeejjZd8d9ed:<d;d9ed<<ee:jeefZd=ed><e jddCdDZejGdEdFdFZejGdGdHdHZejGdIdJdJZejGdKdLdLZGdMdNdNZe jddPdQZejddUdVZejddWdXZejGdYdZdZZGd[d\d\eZGd]d^d^eZGd_d`d`eZddddeZddidjZe jddmdnZe jddodpZe jddrdsZejGdtduduZddzd{Zd|Zdd~dZdddZdddZGdddeZejGdddZGddSdSedZGdddeZejdkrwddejDZejdddZ GdddeZ Gddde Z dS)a Core module responsible for converting Python bytecode into TorchDynamo's symbolic execution format. This module implements the bytecode-level tracing system that allows TorchDynamo to analyze and transform Python code. It converts Python bytecode instructions into a symbolic format that tracks the flow of tensors and other values through the program. Key components: - InstructionTranslatorBase: Base class for converting bytecode to symbolic execution - InstructionTranslator: Main translator for function bytecode - InliningInstructionTranslator: Handles inlining of called functions - SpeculationLog: Manages state for speculative execution and rollback The symbolic conversion process handles: - Control flow (loops, conditionals, etc.) - Function inlining and call stack management - Tracking of program values and side effects - Graph breaks and resumption points - Exception handling and stack frame management This is a core part of TorchDynamo's tracing system that enables ahead-of-time optimization of PyTorch programs. ) annotationsN)deque)AnycastNoReturnOptional TYPE_CHECKING TypeAliasUnion)TypeIs)DynamoProfilerStateFunctionTraceTiming)ObservedExceptionTensorifyScalarRestartAnalysis)InlinedCodeCachetracingTracingContext) dump_file) guard_bool) cache_method)configexcgraph_break_hintslogging trace_rules variables) get_indexof JUMP_OPNAMESlivevars_analysispropagate_line_nums)cleaned_instructionscreate_binary_slicecreate_call_functioncreate_call_function_ex create_copycreate_dup_topcreate_instructioncreate_jump_absolute create_rot_n create_swap get_code_keys Instruction is_generatoris_jump_absolute unique_id) code_context) PyCodegen) !augment_exc_message_with_hop_nameBackendCompilerFailedcollapse_resume_framesformat_frame_infoget_stack_above_dynamoResumePrologueTracingErrorStepUnsupported unimplemented Unsupported) get_funcname) GuardBuilder install_guard)GraphCompileReason OutputGraphStackLocalsMetadata)impl_CONTAINS_OP_fallbackimpl_IS_MAPPINGimpl_MATCH_CLASSimpl_MATCH_KEYSimpl_MATCH_SEQUENCE) DummyModuleExecutionRecorder)ContinueExecutionCache"IS_TRACING_RESUME_PROLOGUE_VARNAME ReenterWithTORCH_DYNAMO_RESUME_IN_PREFIX) AttrSourceDictGetItemSource GlobalSourceGlobalWeakRefSourceLocalCellSource LocalSourceSkipGuardSourceSource)is_builtin_constant is_forbidden) _get_error_on_graph_breakcountersget_fake_valueget_instruction_source_311get_metrics_contextgraph_break_dup_warning_checkeristype LazyStringproxy_args_kwargs)typestrValueMutationNewVariableTracker)FrameStateSizeEntryVariableBuilder wrap_fx_proxy)BuiltinVariable)CONSTANT_VARIABLE_NONEConstantVariable)ContextWrappingVariableGenericContextWrappingVariableWithEnterFunctionVariableWithExitFunctionVariable)ConstDictVariable SetVariable)BaseUserFunctionVariableLocalGeneratorFunctionVariableLocalGeneratorObjectVariableNestedUserFunctionVariableSkipFunctionVariableUserFunctionVariableUserMethodVariable)MAX_ITERATOR_LIMIT)LazyVariableTracker)BaseListVariableIteratorVariableListIteratorVariable ListVariable SliceVariable TupleVariable) CellVariableExceptionVariableGetAttrVariable NullVariablePythonModuleVariableTracebackVariableUnknownVariable)NNModuleVariableUnspecializedNNModuleVariable)SymbolicStreamState)supported_comparison_opsSymNodeVariable)SymbolicTorchFunctionStateTorchFunctionModeVariable)RemovableHandleVariableUserDefinedClassVariable!UserDefinedExceptionClassVariable"UserDefinedExceptionObjectVariableUserDefinedObjectVariable)Callable GeneratorSequence)FakeTensorMode)CompilePackage graph_breaks trace_call trace_sourcetrace_bytecodecCsi|] \}}|t|jqS)re call_function.0kvrrh/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/_dynamo/symbolic_convert.py srdict[str, Any]compare_op_handlerscCst|gt|iSN)handle_containsreversedtxargs_rrrsrincCst|t|gt|igiSr) handle_notrrrrrrrsznot inr ExceptionValsnamestrreturntypes.ModuleTypecCs t|S)z Import the named module and cache the result. importlib.import_module() seems to do some filesystem checking to validate the name so not caching this can be slow. ) importlib import_module)rrrr_import_modules rc@sfeZdZUded<ded<ded<ded<dZd ed <d Zd ed <d Zded<dddZdddZd S)SpeculationEntryrfilenameintlinenoinstruction_pointerr,instFbool_failedNzOptional[bool]error_on_graph_breakzOptional[GraphCompileReason]reasonrNonecCs0d|_||_|jdur|jj}nd}tj|d)z\ Start tracing of the current frame over again, and don't take this branch. TNz!Unknown fail_and_restart_analysis)restart_reason)rrrrSpeculationRestartAnalysis)selfrrrrrfail_and_restart_analysiss    z*SpeculationEntry.fail_and_restart_analysisrInstructionTranslatorBasecCs$|jr|jdus J|j|_dSdSNTF)rr)rrrrrfaileds zSpeculationEntry.failed)rrrr)rrrr) __name__ __module__ __qualname____annotations__rrrrrrrrrrs      rc@s\eZdZUdZejedZded<dZ ded<dZ d ed <dd dZ dddZ dddZ dS)SpeculationLoga3 SpeculationLog replaces the prior copy_graphstate/restore_graphstate checkpointing. Rather than saving/restoring state, we restart the dynamo conversion process over from the beginning -- but when we hit the start of the speculation that failed, we instead generate a graph break. default_factoryzlist[SpeculationEntry]entriesrrindexFrgraph_break_on_autograd_gradrrcCs d|_dSNr)rrrrrrestart zSpeculationLog.restartcCs|jd|_dSr)rclearrrrrrr"  zSpeculationLog.clearrrrrrr,rcCst|j|jkr|jt|||||j|j}d}|jdkr<|j|jd}d|jd|jd|jjd|j d }|j |krK|j|krK|j|ks{t d |jd t|jd |jd|jd |jjd |j d|d|d |jd |d|d|jd7_|S)z Lookup or create a SpeculationEntry() that is shared across RestartAnalysis calls. Args are used only for debug checks. rrzPrevious instruction: :(z @ z) z" SpeculationLog diverged at index z (log had z entries): - Expected:  (z at ip=z ) - Actual: a There are two usual reasons why this may have occurred: - When Dynamo analysis restarted, the second run took a different path than the first. If this occurred, the previous instruction is the critical instruction that behaved differently. - Speculation entries are only added under certain conditions (as seen in step()), e.g., there must exist operators in the graph; those conditions may have changed on restart. If this divergence was intentional, clear the speculation log before restarting (do NOT do this for graph breaks, you will infinite loop). Otherwise, please submit a bug report, ideally including the contents of TORCH_LOGS=+dynamo ) lenrrappendrrrropnamerSpeculationLogDivergence)rrrrrentryprev_entry_msg prev_entryrrrnext&sX      zSpeculationLog.nextNrr) rrrrrrrr,rr)rrr__doc__ dataclassesfieldlistrrrrrrrrrrrrs     rc@s,eZdZUejedZded<d ddZdS) LocalStaterzdict[str, FrameStateSizeEntry]automatic_dynamicrrcCsddd|jDS)N css&|]\}}|d|VqdS): N)renderrrrr ]s z$LocalState.render..)joinritemsrrrrr\s zLocalState.renderNrr) rrrrrdictrrrrrrrrVs rc@s*eZdZUded<ded<dZded<dS)DistributedStater compile_pgr local_stateNzOptional[list[LocalState]] all_states)rrrrrrrrrrcs rc@sTeZdZUeZded<edddZedd d Zedd d Z edddZ dS)TensorifyStatezset[str]force_specializationsrrrrcC|j|dSr)raddclsrrrr specializepszTensorifyState.specializercCs ||jvSr)rrrrrshould_specializet z TensorifyState.should_specializecC|jdSr)rrrrrrrxzTensorifyState.clearcCst|jdkSr)rrrrrrempty|rzTensorifyState.emptyN)rrrr)rrrrrrr) rrrsetrr classmethodrrrrrrrrrjs    rCallable[..., None]cCs ttSr)torchdynamo_loggingget_step_loggerlogrrrr _step_loggerrr rrGenerator[None, None, None]ccsR|jj}|jj}zg|j_d|j_dVW||j_||j_dS||j_||j_wr)speculation_logrr)rrrrrr save_and_restart_speculation_logs   r ccs2z|jj}d|j_dVW||j_dS||j_wNF)output should_exit)rtmprrr(temporarely_allow_writes_to_output_graphs rc@sPeZdZUded<ded<ded<dZded <dd d ZdddZdddZdS)BlockStackEntryr,rzInstruction | Nonetargetr stack_indexNzHOptional[Union[ContextWrappingVariable, GenericContextWrappingVariable]] with_contextrrcCs |jduSr)rrrrr can_restorerzBlockStackEntry.can_restorerJcCsN|jdusJ|jr t|jdr |jjr t|jdt|jjSt|jdS)N target_valuesr)rrhasattrrrJtuplerrrr resume_fns zBlockStackEntry.resume_fnrris_graph_breakVariableTracker | NonecCs0|jdusJ|r|js|s|j|SdSr)rexit_on_graph_breakexit)rrrrrrrs zBlockStackEntry.exitr)rrJ)rrrrrr)rrrrrrrrrrrrrs    rc@ eZdZdS)rNrrrrrrrrrc@r ) ReturnValueOpNr!rrrrr#r"r#c@seZdZdZdS) YieldValueOpzY Signal to the symbolic tracer to stop and return control flow to the caller N)rrrrrrrrr$sr$fnCallable[..., object]Callable[..., Any]cs6tt|jt|t|d fdd }|S) NrInstructionTranslatorrr,rrcs|||idSr)pushrpopnrrfn_varnargsrrimplszstack_op..impl)rr(rr,rr)rinspect signature parametersre functoolswraps)r%r/rr,rstack_ops r5modobjectrcCs&t|tjsdS|jddtjvS)NF.r) isinstancetypes ModuleTypersplitsysstdlib_module_names)r6rrr is_stdlibs r?with_msg list[str]cCsb|rddd}nddd}dd t|D}td d t|D}|d }||d |d S)NxrrrcSs|sJddS)NmsgrrBrrrr%z(get_assert_bytecode_sequence..fncSs |sJdSrrrDrrrr% cSg|]}|jqSrrrrrrr z0get_assert_bytecode_sequence..css"|] \}}|dr|VqdS)POP_JUMPN) startswith)rirrrrrs z/get_assert_bytecode_sequence.. RAISE_VARARGSr)rBrrr)disget_instructionsr enumerater)r@r%insts begin_idxend_idxrrrget_assert_bytecode_sequences   rVcCsbtjdksJd dd}ddt|D}t|d|d d d d }|d }|||S)zNGet the bytecode instructions that precede BUILD_LIST in a list comprehension. r list[int]cSddtdDS)NcSg|]}|qSrrrrNrrrrJzB_get_comprehension_bytecode_prefix..fn..rrangerrrrr%z._get_comprehension_bytecode_prefix..fncSrGrrHrIrrrrJrKz6_get_comprehension_bytecode_prefix..rNLOAD_FAST_AND_CLEAR BUILD_LISTrrZ)r= version_inforPrQrr)r%rS start_idxrUrrr"_get_comprehension_bytecode_prefixs     rhdict[str, dict[str, Any]]c CstjdksJddd}ddd}dd d }dd d }ddd}||}||}||}||}|d|dd|d|dd|d|dd|dgddS)aDiscover bytecode patterns for comprehension result handling. Analyzes sample functions to extract the opcode sequences that appear after END_FOR for each result disposition (stored, discarded, returned, consumed). Returns patterns with: - pre_store_ops: opcodes between END_FOR and first STORE_FAST - post_store_op: first opcode after all STORE_FASTs (for disambiguation) rWrrZcSsddtdD}|S)NcSr\rrr]rrrrJr^zI_get_comprehension_result_patterns..fn_stored..rr_)resultrrr fn_storedz5_get_comprehension_result_patterns..fn_storedrcSsddtdDdS)NcSr\rrr]rrrrJ"r^zL_get_comprehension_result_patterns..fn_discarded..rr_rrrr fn_discarded!rlz8_get_comprehension_result_patterns..fn_discardedcSr[)NcSr\rrr]rrrrJ&r^zK_get_comprehension_result_patterns..fn_returned..rr_rrrr fn_returned%raz7_get_comprehension_result_patterns..fn_returnedcSstddtdDS)NcSr\rrr]rrrrJ)r^zK_get_comprehension_result_patterns..fn_consumed..r)sumr`rrrr fn_consumed(z7_get_comprehension_result_patterns..fn_consumedr%r'tuple[list[str], Optional[str]]c Ss&tt|jdd}g}d}t|D] }|r|jrn|j}|r5|j|kr5|p.t|j}| |j q|| ddd}d}g}|t |krh||dkrh| |||d7}|t |krh||dksQ|t |kr||dkr|d7}|t |kr||dkst||t |kr||fSdfS)zCExtract (pre_store_ops, post_store_op) from comprehension bytecode.rFEND_FORNr STORE_FAST) rrPfindlinestarts__code__rQ starts_line positionsrrrrrr) r% target_linerSstartedinstrposopsidx pre_store_opsrrrextract_pattern+s,  z;_get_comprehension_result_patterns..extract_patternrr)r post_store_op)stored discardedreturnedconsumedNrerr)r%r'rrr)r=rf) rkrmrnrprrrrrrrr"_get_comprehension_result_patternss      rc@sBeZdZUdZded<ded<ded<ded <ded <ded <d S) ComprehensionAnalysisa9Metadata about a comprehension's bytecode structure. Attributes: end_ip: Instruction pointer after all comprehension bytecode result_var: Name of result variable, or None if result stays on stack result_on_stack: True if result stays on stack (discarded, returned, or in expression) iterator_vars: Variables from LOAD_FAST_AND_CLEAR (need restoration) walrus_vars: Variables assigned via walrus operator (:=) inside comprehension captured_vars: Variables read from outer scope via LOAD_FAST inside comprehension rend_ipz Optional[str] result_varrresult_on_stackrA iterator_vars walrus_vars captured_varsN)rrrrrrrrrrRs   rrtruth_fnCallable[[object], bool]r)c Cs|tjus|r dSt|jtsJ|j}dD]9}t|}|j||t|}dd|D}||krO|rB|d}|j||j }nd}| t |dSqdS)NF)FTcSrGrrHrIrrrrJrKz:_detect_and_normalize_assert_statement.. LOAD_CONSTzassertion errorT) operatortruthr9rrrV instructionsrrargvalr)rgcreate) rrr)current_instruction_pointerr@ assert_insts cur_instsload_const_idx error_msgrrr&_detect_and_normalize_assert_statementgs2  rF8Callable[[InstructionTranslatorBase, Instruction], None]cs6ddd ddfdd dfdd }|S)NvaluerarrcSs$tdd|dgtjdddS)NzData-dependent branchingzattempted to jump with zyDetected data-dependent branching (e.g. `if my_tensor.sum() > 0:`). Dynamo does not support tracing dynamic control flow.z1Use `torch.cond` to express dynamic control flow.gb_typecontext explanationhints)r9r FUNDAMENTALrrrrraise_jump_graph_breaks z,generic_jump..raise_jump_graph_breakrrrrr, extra_msgrrc sP|sJd}z|Wnty"}z|}WYd}~nd}~ww|dus)J|r4||j||j|jt||d||t d|j j |t dt|||gdd}|||j|}rq|||jdusxJ||j|}tjdkr|j tdgt|j|dd } | ||j | g||dS) Nrrzgeneric_jump triggered compilez generic_jump rr stack_popsrX TO_BOOLr)r)should_compile_partial_graphr:maybe_has_backedgeraise_loop_graph_breakf_codelog_graph_break code_optionsrr)r debugrcompile_subgraphr>r_ frame_summarypopcreate_call_resume_atnext_instructionrr=rfadd_output_instructionsr'rcopy_positions) rrrrreall_stack_locals_metadataif_nextif_jump jump_inst)r)rrrjump_graph_breaksT        z&generic_jump..jump_graph_breakc s|}tjrt|r|}|r?t|r ||S|r+|||nt dd|dgt j dddd| r[|j jdtjgt||fiR||dSt|tr|j}t|tjsm|d k}tjjj|}|st d t|d gt jd||dS|j jdtjgt|fiR}t||t|j|d }|j jdtjgt||fiR||dS|rt|t r|j!rt"|j!#t$j%|rr|&|||dSdS| r|r|||dSt|t'r|j (|j)}|rr|&|||dSdSt|t*rz|+|d } Wn+t,j-yUt,.|z|+|d} Wnt,j-yRt,.|d} YnwYnwt| t/r| 0|gi}t1t1| dddd} |r|} | d krt| tst2j34dt5| j6} t,j7t8|| gdt| tt9fr| rr|&|||dSdSdSt|tr|:rЈr|&|||dSdSt dd| d|dgddSdrr|&|||dSdS| s|;|rt<|=|rr|&|||dSdSt|trxzt|jtjr4|:|j } nt>|jd k} Wn%t,j?ya}z|r\|||d|dWYd}~Sd}~ww| rvro|&|||dSdSt|t2j@rdrr|&|||dSdSddl!mA}|j!dur||j!r|Brr|&|||dSdS|dS)Nz>Data-dependent assertion failed (cannot compile partial graph)zvalue: zuDynamo has determined when encountering a data-dependent assert failure that it should not compile the partial graph.zUse `torch._assert()` to raise a hard AssertionError when the check fails. This error will propagate back the user code that called the compiled function (i.e. Dynamo will not trace any exception handling).zRemove the assert statement.zMove the assert statement outside of any context managers in order to graph break with partial graph compilation (if fullgraph=False).rrrz#Assertion failed on symbolic shapesr) example_value__bool____len__r%rz&__bool__ should return bool, returned rz3Data-dependent branching with non-constant __bool__zmethod: z , result: z}Attempted to perform data-dependent branching on a user-defined object with a __bool__ method that did not return a constant.Tr)rr)is_constant_source)Crr rewrite_assert_with_torch_assertris_python_constantras_python_constantjumprr9rr is_tensorr create_proxytorch _assert_asyncr^r9rsym_numSymBoolfx experimentalsymbolic_shapes expect_truer USER_ERROR scalar_tensorrdrXnoderlsourcer= make_guardr<SEQUENCE_LENGTHr)r get_submodule module_keyr var_getattrrObservedAttributeErrorhandle_observed_exceptionrtrgetattrrrgrtyperraise_observed_exception TypeErrorr evaluate_exprhas_unpack_var_sequencerunpack_var_sequencer UserErrorBackwardHookVariablerget_real_value)rrrrsym_exprrjscalar_to_tensor_proxyscalar_to_tensorr6rB method_name result_valuerC eval_resultrrrr)rrrrinnersJ                               "       zgeneric_jump..inner)rrarr)r) rrrr,rrarrrrrrrr,rrr)rr)rrrr generic_jumps 9:rcgr1cleanuplist[Instruction]rcCsg}|}|dur|||j}|dust|D]<}|jD]6}t|jtr2|| |j |q|jdus9Jt|jt sAJ|j ||| |j |qqdS)zsGenerates bytecode to restore the block stack for running the unsupported instruction in the compiled bytecode.N)rparentr block_stackr9rr extend_outputrtry_except_torch_function_moderrhreconstruct_type try_finally)rrrall_txescur_txbrrr_reconstruct_block_stacks*     r msg_prefixYCallable[[Callable[..., None]], Callable[[InstructionTranslatorBase, Instruction], None]]csdfdd }|S)Ninner_fnrrrcs0td fdd }dfd d |S)Nrrrr,rrc s@|j}|_|}||r|jdusJ|||jSzvz ||WW||_Sty}zZ|jrO|js9|jr:|t dd|jddgt j |d|j rS| sX|rc||j||j|jdt||d||dt|j|j|_WYd}~nd}~wwW||_n||_w||jdS) Nz0Graph break under GenericContextWrappingVariablez!Active generic context managers: z]Attempted to graph break in an active context manager(s) that doesn't support graph breaking.zEMove the offending context manager(s) to outside the compiled region.rrrrfrom_excz: r graph_break)current_instruction_push speculaterrr:active_generic_context_managers one_graphrremove_from_statsr9rCAUSED_BY_EARLIER_GRAPH_BREAK skip_framerrrrrrr add_to_statsr>rC real_stackr)rr prev_push speculationexcp)handle_graph_breakrrr)rrwrappersV  (    %z>break_graph_if_unsupported..decorator..wrapperrr>c stjdkr$tjdkr$|jdkr$ttjd|jttjd|j}nt|j|j}t d|j|j j ||t |d}t |j j}g}t||||j |~tjdkr|jdkr|jdurk|jnd}t|dkrtjd kszJ|j td |d g|jdusJt|jd }|d ||j |n|jdusJt|} d| _|j | g|j ||t |r|t|j ||j|dS)NrX rWCALLPRECALLz%s triggered compilerrrrKW_NAMESrFrb) r=rfrrP stack_effectopmapargopcoder rrrrr1root_txrrrQkw_namesrrr'r#rrcopy exn_tab_entryr*r)rrr) rrrrrrrr  call_insts inst_copyr)rrrs\              zIbreak_graph_if_unsupported..decorator..handle_graph_breakr)rrrr,rr>rr)r3r4)rrrr))rrr decorators4>z-break_graph_if_unsupported..decorator)rrrrr)r)rr'rr&rbreak_graph_if_unsupportedsxr(cs"eZdZdZd fd d ZZS)BytecodeDispatchTableMetazTInstalls a `cls.dispatch_table` on every subclass to speed up calls to self.OPCODE()rrrrbasesrdctrrcsPt|||dddfd d tjDfd d td D_dS)NrrrrrrcWs6td|d|d|dd|dgtjddS)NzMissing bytecode handlerz with args z=Dynamo does not know how to handle the bytecode instruction ``.z%Do not trace code that produces the `z_` bytecode instruction (see https://docs.python.org/3/library/dis.html for bytecode semantics).r)r9r SUPPORTABLE)rrrrr_missing]s    z4BytecodeDispatchTableMeta.__init__.._missingc s&i|]\}}|t|t|qSr)rr3partial)rrop)r.rrrrisz6BytecodeDispatchTableMeta.__init__..csg|]}|qSr)getr])dispatch_tablerrrJnz6BytecodeDispatchTableMeta.__init__..)rrrrrr)super__init__rPrrr`r2)rrr*r+ __class__)r.rr2rr6Zs   z"BytecodeDispatchTableMeta.__init__) rrrrr*rr+rrr)rrrrr6 __classcell__rrr7rr)Wsr)c@seZdZUdZejedZded<ejddZ ded<d)d d Z d*ddZ d)ddZ d+ddZ d,ddZd*ddZd*ddZd+ddZd*dd Zd-d!d"Zd.d$d%Zd/d'd(ZeZdS)0ExceptionStackzU Exception stack that it is shared among all InstructionTranslator instances rzlist[ExceptionVals] _exc_stackN)defaultzOptional[ExceptionVals]_current_exceptionrrcCs d|_dSrr=rrrrclear_current_exceptionrz&ExceptionStack.clear_current_exceptionvalrcCs||||_dSr)._set_context_and_break_context_reference_cycler=rr@rrrset_current_exceptionrz$ExceptionStack.set_current_exceptioncCs&|jdusJ||j|dSr)r=rr?rrrrmove_current_exception_to_stacks  z.ExceptionStack.move_current_exception_to_stackcCs|jdusJ|jSrr>rrrrget_current_exceptionsz$ExceptionStack.get_current_exceptionprev_idxrcCsT|j}r t|tur |St|j|dkr(|j|}|||d|||SNrr) __context__rrgrr;_set_context_recursive set_context)rr@rFctxprevrrrrIs  z%ExceptionStack._set_context_recursivecCs\|}}d} |j}t|turdS||ur|tdS|}||ur%dS|r*|j}| }qr)rHrrgrJrf)rr@oslow_oslow_update_togglerrrr_break_context_reference_cycles   z-ExceptionStack._break_context_reference_cyclecCs$||t|jd||dSNr)rIrr;rPrBrrrrAsz=ExceptionStack._set_context_and_break_context_reference_cyclecC |jSr)r;rrrrrrrzExceptionStack.popcCrr)r;rrBrrrrrEzExceptionStack.appendcCs t|jSr)rr;rrrrrrzExceptionStack.__len__rcCs |j|Sr)r;)rrrrr __getitem__rzExceptionStack.__getitem__rcCsd|jd|jS)Nzself._exc_stack=z - self._current_exception=)r;r=rrrr__str__zExceptionStack.__str__r)r@rrr)rr)r@rrFrrrr)rrrrr)rrrrrrrr;rr=r?rCrDrErIrPrArrrrSrT__repr__rrrrr:qs"            r:cs eZdZUded<ded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded <d!ed"<d#ed$<d%ed&<d'ed(<ded)<ded*<d+ed,<ded-<d.ed/<d0ed1<d2ed3<d d6d7Zdd8d9Zdd;d<Zdd=d>Zdd?d@Zd dAdBZ ddGdHZ ddKdLZ ddNdOZ dddRdSZ ddTdUZddVdWZddXdYZejdZkrՐdd\d]Zndd^d]Zedd_d`ZddbdcZddddeZd dfdgZddjdkZddmdnZddodpZddrdsZddtduZddvdwZddxdyZddzd{Z dd|d}Z!eZ"dd~dZ#dddZ$dddZ%e&j'dddZ(dddZ)dddZ*e+d ddZ,d!ddZ-dddZ.dddZ/e/Z0dddZ1e+d"ddZ2dddZ3d#ddZ4e4Z5e4Z6e7e8j9dZ:e7e8j;dZdddZ?dddZ@dddZAdddZBdddZCdddZDdddZEdddZFdddZGd$ddZHd%ddZId&ddZJdddZKdddZLddd„ZMd'ddńZNdddDŽZOd(dd˄ZPddd̈́ZQdddτZRdddфZSdddӄZTdddՄZUdddׄZVdddلZWeXdddۍddd݄ZYeXdddۍdddZZeXdddۍdddZ[dddZ\dddZ]dddZ^dddZ_d)ddZ`dddZaeXdddۍdddZbdddZcedd*ddZed+ddZfd,dd Zgedd-d d Zhdd dZieXdddۍdddZjdddZkdddZldddZmdddZnd.ddZodddZpdddZqerfd/d"d#Zsdd$d%ZtetZudd&d'Zvdd(d)ZwewZxdd*d+Zydd,d-Zzdd.d/Z{dd0d1Z|dd2d3Z}dd4d5Z~dd6d7Zdd8d9ZeXdd:dۍdd;d<Zdd=d>Zdd?d@ZddAdBZddCdDZddEdFZddGdHZddIdJZd0dMdNZd1dQdRZddSdTZddUdVZddWdXZddYdZZdd[d\Zdd]d^Zdd_d`ZddadbZeZddcddZddedfZddgdhZddidjZddkdlZddmdnZddodpZddqdrZee8jZee8jZee8j9Zee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZeXddsdۍee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jÃZee8jŃZee8jǃZee8jɃZee8j˃Zee8j˃Zee8j΃Zee8jЃZee8j҃Zee8jԃZee8jփZee8j؃Zee8jڃZېddtduZejdZkrddvdwZݐddxdyZސddzd{Zߐdd|d}Zd2d3ddZeXdddۍdddZdddZdddZe4Ze4Ze7e8j;dZe7e8j;dZe7e8j9dZe7e8j9dZdddZdddZd4ddZedd5ddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZeXdddۍdddZdddZdddZdddZdddZdddZeZeZeZdZdddZdddZdZdddZdddZ Pdd6dd„Z d7dĐdńZ ddƐdDŽZ d8dɐdʄZ ed9d̐d̈́Z ejd:dАdфZd;dӐdԄZddՐdքZd<dאd؄Zd=dڐdۄZddܐd݄Zd>ddZd?ddZd@ddZdAddZdBddZeddCddZ P P PdDdEfd d ZZS(Frr?rdict[str, VariableTracker]symbolic_localssymbolic_globalsrsymbolic_torch_function_statersymbolic_stream_statez$Optional[dict[str, VariableTracker]]post_prune_cell_and_freevarslist[VariableTracker]stack Optional[int]rr,current_instructionrrzlist[BlockStackEntry]rrrzOptional[ConstantVariable]r accept_prefix_instr prefix_insts inline_depthinconsistent_side_effectszOptional[SpeculationEntry]current_speculationz list[Any]r2r: exn_vt_stackzOptional[ExecutionRecorder] exec_recorderz+Optional[Callable[[VariableTracker], bool]]strict_checks_fn start_pointhas_no_inlined_callsz#Optional[InstructionTranslatorBase]ris_child_tracer_activez3list[tuple[VariableTracker, list[VariableTracker]]] debug_localsOptional[CompilePackage]packagez deque[str]latest_bytecode_queuerrcCs d|_dS)z InstructionTranslator has encountered instructions which may cause dynamo to see a different version of history from eager See: https://github.com/pytorch/pytorch/issues/110765 TN)rdrrrrmark_inconsistent_side_effectss z8InstructionTranslatorBase.mark_inconsistent_side_effectscCsv|}|dur9|jj}|jdusJ|j|jdD]}|jdvr"n|jtvr1|j}||kr1dSq|j}|dusdS)N) RETURN_VALUE RETURN_CONSTTF)r`offsetrrrrrr)rr cur_offsetr jump_offsetrrrrs   z,InstructionTranslatorBase.maybe_has_backedgerAcC |jdS)N co_cellvarsrrrrrcellvars$rz"InstructionTranslatorBase.cellvarscCrv)N co_freevarsrxrrrrfreevars'rz"InstructionTranslatorBase.freevarscCs"t|ds|||_|jS)N_cell_and_freevars)rryr{r|rrrrcell_and_freevars*s z+InstructionTranslatorBase.cell_and_freevarscsFfddjD_tjjfddjD_dS)Ncs"i|] \}}|vr||qSrr}rrrrr1s  z?InstructionTranslatorBase.prune_dead_locals..csi|] \}}|vr||qSrrr)readsrrr8s)rXrr\rrr`rrrrrprune_dead_locals/s   z+InstructionTranslatorBase.prune_dead_localsr%rarkwargscCst|tsJt|tsJt|tsJtddt||Ds&Jd}t|dr0|j }t|dr8|j }|rIt |rIt |rIt d||||||dS)Ncss|]}t|tVqdSr)r9rarrBrrrrEs  z:InstructionTranslatorBase.call_function..rr%z$Attempt to trace forbidden callable )r9rarrall itertoolschainvaluesrrr%callablerUAssertionErrorr)r)rr%rrrrrrr<s   z'InstructionTranslatorBase.call_functionrnSequence[VariableTracker]cCs t|ts t|}||||S)zD Redirect the call to the generator "call_function" )r9rorrr%rrrrrinline_generator_functionRs z3InstructionTranslatorBase.inline_generator_functionrcCs0tjrt|r||||St||||S)zF A call to some user defined function by inlining it. )r"enable_faithful_generator_behaviorr-get_coderInliningInstructionTranslator inline_callrrrrinline_user_function_return_s z5InstructionTranslatorBase.inline_user_function_returnNrcCst|dur|j}|jdkrd|jdnd}t|jj|}|dur"dnd|d}|jjd|d|jj||S)Nrz (inline depth: )rrrz in )rrcr;r co_filenameco_name)rrinline_depth_strfuncname funcname_strrrrget_line_of_code_headerms$z1InstructionTranslatorBase.get_line_of_code_headercCs8d|d}t|jj|j}|d|7}|S)NzTRACE starts_line rz )r linecachegetlinerrrrstrip)rlog_strlinerrrget_log_starts_line_log_strwsz5InstructionTranslatorBase.get_log_starts_line_log_strcCsJ|j|krdS||_t|jj||jj|jr#tdt |j dSdS)N%s) rrset_current_locrrris_trace_source_log_enabledtrace_source_logrr]r)rrrrrrw}s z%InstructionTranslatorBase.starts_linec Csjt|_|j}|dur dS|j||_}|d|_|jr#||j|js@|r@|r@| |_ |j |r@| |dS|j rPtd|j|jt|jtjryzt|j}Wn tyed}Ynw|jd|jdt|jd|||z|j|j|||jj WStytjy}z | |WYd}~dSd}~wt!t"fyYdSt#t$fy+}ze|j%s|js|j&st'|t#r|j(rt'|t$rt)d d d d d gt*j+d|j durt,dt'|t$rt)dd dd dgt*j+ddt'|t#s Jd|_(dt-|}|j.|j/||dWYd}~nd}~ww|j 0|jdS)zzTRACE  Tz3cannot resume from torch._dynamo.step_unsupported()rztraced torch._dynamo.step_unsupported(), but Dynamo is instructed to error on graph break. This graph break is used for debugging only.z1Remove the torch._dynamo.step_unsupported() call.z9Make sure fullgraph=False and error_on_graph_break=False.rz1empty checkpoint - cannot resume from graph breakz6torch._dynamo.step_unsupported() with empty checkpointztraced torch._dynamo.step_unsupported(), but there is no checkpoint to step_graph_break from. This graph break is used for debugging only.zInclude at least one checkpoint: (1) include at least 2 ops and (2) make sure there is some line of code that is not in a try/with block, and has an empty Python stack.)rrrrr zEncountered graph break that we cannot resume from. Compiling up to the previous resumable state, then skipping the rest of the function. Graph break encountered: r)1rVrrrr`rwr^ris_non_empty_graphrrerstep_graph_breakis_trace_bytecode_log_enabledtrace_bytecode_logrrrreprrverbose ValueErrorrorupdate_block_stackr2rrrrrrexception_handlerr#r$r:r8r is_tracing_resume_prologuer9r r9r DYNAMO_BUGr rrrr)ripr stack_reprrrrrrsteps                :zInstructionTranslatorBase.steprrcCs|j}|r+t|jdkr%|j|jdjur'|j|jdjur)|jdSdSdSdS|jrC|jdvrEt|jdksrr eval_framerrnested_graph_breaksr1rrr%create_load_constcreate_binary_subscrr' create_resumercodegen_call_resume num_stackr"r*r)rr&rrQrr locals_namesr create_storer(r) rrrrrleaf_resume_codeleaf_resume_namerrlocalr~rrrr1s               z*InstructionTranslatorBase.step_graph_breakcCs tdSr)r current_framerrrr run_ctx_mgrs z%InstructionTranslatorBase.run_ctx_mgrc Cs|t|jjzz<|j||j|_z |r! |sWn$t yF}z|j rAt dt |j dt||jdd}~wwWnotyPtyWty}z@t|tr~t|tr~|js~|js~dt|}|j|j||dt|drd|jvrtj|jj |jj!j"dddd }||_#d}~wt y}z |j$r|j$%|_&d}~wwW|j't|tr|j(|j)n|j't|tr|j(|j)wwWddS1swYdS) NzError while tracing through a Dynamo-generated resume function prologue. Errors are not allowed when tracing resume function prologues. rztFailed to handle graph break gracefully. Skipping the function and falling back to eager. Graph break encountered: rrCzData-dependentFT) print_outputinclude_strideinclude_device)*rrrrrpush_txrrir Exceptionrr7rrrwith_traceback __traceback__rr3 RuntimeErrorr9r:r(rr rrrrCrr GraphModule nn_modulesgraphprint_readablepartial_fx_graphrg get_record exec_recordpop_txrmark_bytecode_tracing_stop)rrrreadable_graphrrrruns               "zInstructionTranslatorBase.runr@Optional[VariableTracker]cCs4|dust|tsJdt||j|dS)Nz"push expects VariableTracker, got )r9rar_r^rrBrrrr)Es zInstructionTranslatorBase.pushvalscCs|D]}||qdSrr%)rrr@rrr push_manyKs z#InstructionTranslatorBase.push_manycCrRr)r^rrrrrrOrzInstructionTranslatorBase.popncsgtfddt|DS)Ncsg|]}qSrr)rrrrrrJSz2InstructionTranslatorBase.popn..)rr`)rrrrrr*RszInstructionTranslatorBase.popnc Cs|j}|jr||jvr|j||j|z ||j|WnMtyn|drZz| dd}||j|Wn.tyYt dd|d|ddgt j dYnwt d d|d |dgt j dYnw|d r||j |dSdS) Nr8implicitz5Attempted to read undefined local variable (implicit)z LOAD_FAST z5Could not find an implicit local variable with name ``z(This happens in dict/list comprehensionsrz*Attempted to read undefined local variablez+Could not find a local variable with name `__stack)rrgf_locals add_local_varr)rXunwrapKeyErrorrMreplacer9rrr)rrrnew_namerrr LOAD_FASTUs@         z#InstructionTranslatorBase.LOAD_FASTcCsl|j|vs J|j|j}|jj|}|||jr2|j|jvr4|j |j|j|jdSdSdSr) rr}rXr side_effects load_cellr)rgrr)rrcell contents_varrrr LOAD_DEREFxs  z$InstructionTranslatorBase.LOAD_DEREFcCsP|j}|}||||j|<|tkr&|}t|tus!J||_dSdSr) rr set_name_hintrXrIrrrr)rrr loaded_vtr@rrrrts   z$InstructionTranslatorBase.STORE_FASTcCs|j|j=dSr)rXrr+rrr DELETE_FASTz%InstructionTranslatorBase.DELETE_FASTcCsb|j|vs J|j|j}|}|jj||t|ts"J|j dur/| |j dSdSr) rr}rXrrr store_cellr9r} local_namer)rrrr@rrr STORE_DEREFs  z%InstructionTranslatorBase.STORE_DEREFcCsX|j}|durtj|jdS|j|}|s$tj|jd|j|<|j|}|dus*J|S)Nr)rrgrr_constants_cache)rrrNr@rrr _load_consts   z%InstructionTranslatorBase._load_constcCs|||dSr)r)rr+rrrrrUz$InstructionTranslatorBase.LOAD_CONSTcCs|j}|jr&||jvr|j||j|n||jvsJ|j||jj|<||jvr0||S||jvrK|jj |j|}| |jj ||dS|j|}| t ||t|dSr)rrg f_globalsadd_global_var f_builtinsbuiltins load_builtinrYrrr) load_globalrabuildrN)rrrvariablerrrr _load_globals     z&InstructionTranslatorBase._load_globalcCs$d}||}t|}t|||S)Nztorch.nn.modules.module) import_sourcerrar )r module_name module_sourcefglobals_valuerrrnn_modules_globals_vts z/InstructionTranslatorBase.nn_modules_globals_vtcCsj|jdusJtjdkrtjdkr|jdr||||tjdkr1|jdr3||dSdSdS)Nrrr)rr=rf PUSH_NULLr r+rrr LOAD_GLOBALs  z%InstructionTranslatorBase.LOAD_GLOBALcCsr|}|j}t|}||jvrt|j|<|jj||j|}t|t r.t d|dgd|jj |||dS)Nz%Storing Tensor hook handle in globalsThis is not supported.r) rrrNrYr7rrtrack_global_existingr9rr9 store_global)rrrrrr rrr STORE_GLOBALs     z&InstructionTranslatorBase.STORE_GLOBALr rNcCsd|vrtjjj|}|dddddd}n t|}d|dd}|jdur3|j||||jj|<|jj }||vsI|||usIJ|||<|j |t |S) z-Create an alias to a module for use in guards torch_package>r|)NzDynamo found no exception handler at the top-level compiled function when encountering an exception. Exception will propagate outside the compiled region.rrcs\j}t|}t|sJtdd|d|jdgt j t j ddS)NzObserved exceptionrfrrr) rfrErrk python_typer9r9python_type_namerrrr-)rp dynamo_excobserved_exn_gb_explanationrrrrbubble_exception_to_interpreter s  zTInstructionTranslatorBase.exception_handler..bubble_exception_to_interpreterrEXCEPT_HANDLERrXrz#Observed exception (EXCEPT_HANDLER)z This graph break is unexpected.rg.Arrr)&r=rfr`r"rr^depthrlastir)rrgrsrfrErrrdrr(rrrr*r9rrrrDrr,rrrrrergrf) rrrr"rpblock_stack_entry exception_varexcept_handler_inst old_exceptionrrrr s                       z+InstructionTranslatorBase.exception_handlercCsH|}t|jdkrt}n|jd}|||||jdS)Nrrb)rrrfrfr)rD)rrr@prev_excrrr PUSH_EXC_INFO s   z'InstructionTranslatorBase.PUSH_EXC_INFOcCstjdkr|}t|jsJ|jdSt|jdks J|jdjjdkr-td|j| dt|js>J|jdS)NrrrbrzYBug in Dynamo tracing of exception handling.Top of the block stack is not EXCEPT_HANDLER.rX) r=rfrrrfrrrrr*)rrrrrr POP_EXCEPT% s   z$InstructionTranslatorBase.POP_EXCEPTcCs:t|jdks J|}tjdkr|jd}n|j}t|tttt fs7t dt |d|dgt j dtjdkrR||sRt dt |d |dgt j dt|tr[|j}n|g}|D]:}t|tt tfs{t d t |d |dgt j d||rt|j|jrd St|tjrt|j|jrd Sq`d S)Nrrrbz Exception with bad expected typez"`except ...` has unsupported type r8rzCaught non-Exception valuezCExcept expects to receive an object of Exception type but received z#Exception with non-type expectationz!`except ...` expects a non-type: TF)rr^rr=rfr9rer|rrr9rrrrhr issubclassrgr%r)rexpected_exc_types exc_instanceexpected_types expected_typerrrcheck_if_exc_matches: sr           z.InstructionTranslatorBase.check_if_exc_matchescCs|t|dSr)r)rrgrr+rrrCHECK_EXC_MATCH sz)InstructionTranslatorBase.CHECK_EXC_MATCHcCs|s ||dSdSr)rrr+rrrJUMP_IF_NOT_EXC_MATCH sz/InstructionTranslatorBase.JUMP_IF_NOT_EXC_MATCHcCs:|jdkr ||dS|t|j||didS)Nzexception matchr)rrr)rr*r+rrr COMPARE_OP s "z$InstructionTranslatorBase.COMPARE_OPcCs|tt|gidSr)rreiterrr+rrrGET_ITER z"InstructionTranslatorBase.GET_ITERzjEncountered graph break when attempting to trace CALL_FUNCTION: a call to a regular function, e.g. f(x, y))r)rcCs&||j}|}|||idSrr*rrr)rrrr%rrr CALL_FUNCTION s z'InstructionTranslatorBase.CALL_FUNCTIONzjEncountered graph break when attempting to trace CALL_FUNCTION_EX: a variadic function call, e.g. f(*args)cCs`|jdkrti}|}n/|jdkstjdkr*|}t|tr%ti}|}ntdd|jd|jgtj dtjdkrM|}t|tsMJ|}tjd krftjdkrf|}t|tsfJt|t sw| |rwt | |}t|trt|t|}t|t rt|tstd d t|d t|d gtjd|}|||j|dS)Nrrrzz%Variadic function call with bad flagszflags: zHAttempted to call a variadic function (CALL_FUNCTION_EX) with bad flags rrrz0Variadic function call with bad args/kwargs typez args type: z, kwargs type: z2Expected args to be a list and kwargs to be a dict)rrlrr=rfr9rr9rrrwhas_force_unpack_var_sequencer|force_unpack_var_sequencerrecall_custom_dictrr_rkeys_as_python_constantrr)rr kwargsvarsargsvarsnullr%rrrCALL_FUNCTION_EX sT          z*InstructionTranslatorBase.CALL_FUNCTION_EXzyEncountered graph break when attempting to trace CALL_FUNCTION_KW: a function call with keyword arguments, e.g. f(x=True)cCs|}||j}|}t|tr|sJ|}|dt| |t| d}}tt ||}t|t|ksAJ| |||dSr) rr*rr9r|rrrrzipr)rrargnamesrr% kwargs_listrrrrCALL_FUNCTION_KW s &z*InstructionTranslatorBase.CALL_FUNCTION_KWcCs\|tj|dd|jd}|jd|}tjdkr"||dS|tj||ddS)Nrrrco_namesr) rrrrrr=rfr= LOAD_METHODrrrrrrrLOAD_METHOD_SUPER s   z+InstructionTranslatorBase.LOAD_METHOD_SUPERcCs:|tj|dd|jd}|jd|}||dS)Nrrrr)rrrrrr=rrrrLOAD_ATTR_SUPER s z)InstructionTranslatorBase.LOAD_ATTR_SUPERcCsp||j|}tjdkr||||dStjdkr,||||dS|||ddS)Nrr)r=rrr=rfr)rrrobjrrrr s      z%InstructionTranslatorBase.LOAD_METHODcCs:||j}|}|dusJ|}|||idSrr)rrrdummyr%rrr CALL_METHOD s  z%InstructionTranslatorBase.CALL_METHODattrcCs2|}tt||t|gi}||dSr)rrerrrgrr))rrrrjrrrr= s z$InstructionTranslatorBase._load_attrcCs2tjdkr|jdr||dS||jdS)NrWr)r=rfrrr=rr+rrr LOAD_ATTR) s   z#InstructionTranslatorBase.LOAD_ATTRzkEncountered graph break when attempting to trace STORE_ATTR: storing an object's attribute, e.g. x.attr = ycCs2|d\}}tt||t|j|gidSrU)r*resetattrrrgrr)rrr@rrrr STORE_ATTR1 s z$InstructionTranslatorBase.STORE_ATTRcCs*|}tt||t|jgidSr)rredelattrrrgrrrrrr DELETE_ATTR= s z%InstructionTranslatorBase.DELETE_ATTRrcCsbg}|dksJ|dkr|td|jdkrtdntd|jd}|tdtd|g|S)a Debug CPython expects the stack to be empty after the return. Calling compile_subgraph will push cells and frame values to TOS. This function will pop those 2 values from the stack before actually returning. Expects the stack to be: cells, frame values, current frame stack (0 or 1 values) Pops cells and frame values, leaving the current frame stack as TOS. A return instruction is included. rrXrqrrrr)extendr*rr'r)rrrS return_instrrrcodegen_return_with_popsE s   z2InstructionTranslatorBase.codegen_return_with_popsr~ resume_instmetar@ resume_codeslist[types.CodeType]rr1is_leafhandle_inactive_ctxtuple[types.CodeType, str]cs|rzt|j|jD]4\\}} } ttj| } |t| || gt d| || | |t dq |jD]8\} } ttj| } |t| || gt d| || | |j|j| t dqAt|r|jsJ|j}td|j} |rtj|tfddjD}t|jtfdd|D}tfdd|D}| t| || tg|D]}| t| |j|j|| gt dq| t dt d t|d gt dt|jd d n t|j}t|j}tjd kr$t|dks$Jdtjt|j }j!jd us7Jt"#j$j%j!j|jtddj&D|||tddj&D|t|jt|jt|j t|j' }t()j$*ddd}|d urt+,|t()|d<|j-rj./| |d }nj./| t01|j2| | }j3d urj34|j2d|t5d|j6d7<|| fS)a. Creates the resume function for the frame corresponding to `self`. Expects the TOS to be: [frame N cells, ..., frame 1 cells], [ frame N stack + locals, ..., frame 1 stack + locals ] Some additional codegen may happen to prepare the frame stack + locals values for the generated resume function: - inactive context variables in the stack and locals will be replaced by their types - if the frame is a leaf frame, prune dead locals Regardless of codegen, the stack will be left in the same state as before. Args: - idx: depth of this frame: 0 corresponds to the leaf frame (frame N), N-1 to the root frame (frame 1). - resume_inst: the instruction that this frame should resume at - meta: metadata for this frame returned from OutputGraph.compile_subgraph - resume_codes: nested resume code objects generated from previous create_resume calls. - cg: codegen object to output to - is_leaf: True if `self` corresponds to the leaf frame. - handle_inactive_ctx: If True, handles inactive context variables as described above. This is necessary iff the resume function is traced rr __resume_at_c3s(|]}|vr|vr|VqdSrr~rrrrrr sz:InstructionTranslatorBase.create_resume..c3s|] }|vr|VqdSrrrargnames_null_setrrr c3s|] }|vr|VqdSrrrrrrr rrrdrNTrWrz&variables should not be NULL in < 3.12css|]}|jjVqdSr)rrsrrrrrr cs|]}|VqdSr)rrrrrr rorig_graphmodulecSrrrrrrrr z9InstructionTranslatorBase.create_resume..rresumesr)7rstack_ctx_argsstack_ctx_idxes_origrrhr^ append_outputr&rrr*rrr'locals_ctx_argsrXrrr.rr/rsrrrrlocals_null_keysrr"keysr=rfstack_null_idxesr`rHlookuprrrrr0 get_contextr1weakrefrefrzrinstall_global_unsafer: FunctionTyperrnadd_resume_functionrWr)rr~rrrrrrjrj_origrKr resume_name all_argnamesr argnames_nullr stack_lennew_codeorig_graphmodule_maybe package_namer)rrrrre s*                z'InstructionTranslatorBase.create_resumerlist[StackLocalsMetadata]c Csd|_t|jj}g}g}g}|}d}|dur@||ur|} n|j} | jdkr5|||||| |j}|d7}|dust|j t|dj } |sx| dksTJ| t | dt | dD] } |tdqc|td|S|d|ur|td| dd} | |d_n:| t | t | dD] } |tdq|tddd||dj} ||djd7_|dt| gtd||d|t| | d g} |D]}| t|||gt dq| tdtdt|dg| | | gt dt| t dg}g}t|D]$\}}|||||||||||ud \}}||||q*|||||td|S) aP Codegen all resume function(s) from the frame stack starting at `self`, call them, and return the result. Assumes that the unsupported instruction has already been run. Expects the TOS to be: [ frame N locals, frame N-1 stack + locals, ..., frame 1 stack + locals ], *(frame N stack (post-unsupported instruction)) Leaves the result of calling the resume functions on the stack and returns it (empty stack after return). Args: - inst: the instruction of the current (deepest) frame to resume at - all_stack_locals_metadata: metadata returned from OutputGraph.compile_subgraph - contains metadata such as local names, NULL positions, stack length, etc. NrrqrrrrdrT)rr1rrrrrrrr^rrr*r`rr'rQrr)rr%rrr"rr&r!deepcopyrRrr)rrrrtxesidxes resume_instsrr~rcurrent_num_stackrstack_insert_idx filter_instsr resume_namesrN resume_coderrrrr( s                 z/InstructionTranslatorBase.create_call_resume_atrcCs|tdtt||D]9\}\}}|t|dkrn*|jr6|t|||g| ||n || |dd|t dq|t dt dt|ddg|t d|d jr||d |g| |d |d |gt dn|t dg| |d dt d|tt|d |gt d|d t d |gt dt dddt dt d dd|tdd d S)a Calls the provided resume functions. Expects the TOS to be in the state: [frame N cells, ..., frame 1 cells], [ frame N stack + locals, frame N-1 stack + locals, ..., frame 1 stack + locals ] Pops the cells and frame values, leaving the result of calling the resume functions on TOS. Args: - resume_codes: list of resume function code objects to call - resume_names: list of the corresponding names of the resume functions - cg: PyCodegen object to output instructions to rrFrrrdrrXrbr LIST_EXTENDTN)rr%rRrrrzr&rrmake_function_with_closureload_function_namer*r'r)r$)rrrrNrcoderrrr s      z-InstructionTranslatorBase.codegen_call_resumecCsztjdkr|jj}|r|jr|j|jdjurdStdd|jDo<|j o<|jp-|j o<|j o<|j o<|j j jduS)NrrbFcsrrrrrrrrN rzIInstructionTranslatorBase.should_compile_partial_graph..)r=rfr`r"rrrr rkrrr rcurrent_tracerr)rrrrrrE s$   z6InstructionTranslatorBase.should_compile_partial_graphziEncountered graph break when attempting to trace STORE_SUBSCR: trying to store subscript, e.g. x[key] = ycCs(|d\}}}||d||gidS)NrX __setitem__r*ra)rrr@rkeyrrrrX sz&InstructionTranslatorBase.STORE_SUBSCRcCs$|d\}}||d|gidS)Nr __delitem__r)rrrrrrrr` sz'InstructionTranslatorBase.DELETE_SUBSCRcCs||j}|t|dSr)r*rr)r|rrrrrr BUILD_TUPLEd s z%InstructionTranslatorBase.BUILD_TUPLEcCs"||j}|t||ddS)N)r)r*rr)r{rrrr BUILD_SLICEh s z%InstructionTranslatorBase.BUILD_SLICEcCdS)zCheck if comprehension speculation is allowed in nested context. For the base class (non-inlined), this always returns False. Frrrrr#_can_speculate_comprehension_nestedl sz=InstructionTranslatorBase._can_speculate_comprehension_nestedcCstjdkr |jdks dS|sdStdd|jDo2|j o2|j o2|j o2|j o2|j j j du}|r>|j dur>| }|rX|jdkrX|}||rU||dS||_|}|dksbJ|j||jd7_dS) z Handle comprehension start for Python 3.12+ BUILD_LIST/BUILD_MAP with argval 0. Returns True if a graph break was triggered and the caller should return early. rWrFcsrrrrrrrr rzSInstructionTranslatorBase._maybe_setup_comprehension_speculation..NTr)r=rfr_is_comprehension_startrrr rrr rrrr_comprehension_depthrr!_handle_comprehension_graph_breakre_find_comprehension_end_for_ip_comprehension_end_for_ipsr)rr can_speculater end_for_iprrr&_maybe_setup_comprehension_speculations s8      z@InstructionTranslatorBase._maybe_setup_comprehension_speculationcCs2||rdS||j}|t|tddSN mutation_type)r r*rr)rzr`rrrrrd s  z$InstructionTranslatorBase.BUILD_LISTcCs>tjr tdddgd||j}t|td}||dS)Nzmissing BUILD_SET handlerrz:Missing BUILD_SET bytecode handler (for testing purposes).rr )r+inject_BUILD_SET_unimplemented_TESTING_ONLYr9r*rrmr`r))rrrnew_setrrr BUILD_SET s z#InstructionTranslatorBase.BUILD_SETrrc Csx||j}g}|D]%}z |||Wq ty/tdt||dgtjdYq w| ||t ddS)Nz-Failed to unpack object for BUILD_LIST_UNPACKzU cannot be unpacked into a list for the BUILD_LIST_UNPACK bytecode (`[*x, *y, ...]`).rr ) r*rrrNotImplementedErrorr9rrrr)r`)rrrseqsrseqrrrBUILD_LIST_UNPACK s   z+InstructionTranslatorBase.BUILD_LIST_UNPACKcCs|j|tddS)Nr)rr|r+rrrBUILD_TUPLE_UNPACK raz,InstructionTranslatorBase.BUILD_TUPLE_UNPACKcCsX||rdS||jd}tt|ddd|ddd}|t|tddS)Nrrr )r r*rrrr)rlr`)rrrdrrr BUILD_MAP s "z#InstructionTranslatorBase.BUILD_MAPcs^|j}fdd|D}i}|D]}t|tsJ||jqt|tddS)Ncs g|] }tt|giqSr)rerrrrrrrJ s z>InstructionTranslatorBase.BUILD_MAP_UNPACK..r )r*rr9rlupdaterr)r`)rrrrjrBrrrBUILD_MAP_UNPACK s z*InstructionTranslatorBase.BUILD_MAP_UNPACKcCsn|}||j}t|tsJ|sJ||}t|t|ks&J|t t t ||t ddSr ) rr*rr9r|rrrr)rlrrr`)rrrrrrrBUILD_CONST_KEY_MAP s    z-InstructionTranslatorBase.BUILD_CONST_KEY_MAPcCsb|d\}}|jdksJ|jdusJ|j|j }t|ts%J||d||fidS)Nrrr)r*rrr^rXr9rlra)rrrrrrrrMAP_ADD s z!InstructionTranslatorBase.MAP_ADDcCb|}|jdks J|jdusJ|j|j }t|ts J|s&J||d|gidS)Nrrrrrr^r9rm is_mutablerarrrrrrrSET_ADD  z!InstructionTranslatorBase.SET_ADDcCrNrrrrrrr SET_UPDATE r z$InstructionTranslatorBase.SET_UPDATEcCsn|}|jdks J|jdusJ|j|j }t|ts"J|s(J|jj ||j |dSr) rrrr^rXr9rzrrrmutationrrrrrrrs z%InstructionTranslatorBase.LIST_APPENDc Cs|j}tjdkr |}|}tjdkr%t|jdsJtj|jjd}d}d}d}d}tjdkrV|durV|d@r>|}|d@rF|}|d@rN|}|d@rV|}| t |||j ||||dS) Nr co_qualnamerrr|rr) rr=rfrrrrgrr$r)rqr) rrflagsfn_namerdefaultsclosurer kwdefaultsrrr MAKE_FUNCTION s@   z'InstructionTranslatorBase.MAKE_FUNCTIONcs}|r|jt|jd}n.z+Failed to unpack object for UNPACK_SEQUENCEzV cannot be unpacked into a list for the UNPACK_SEQUENCE bytecode (i.e. `a, b, c = d`).rz9Length mismatch when unpacking object for UNPACK_SEQUENCEzexpected length: z , actual: za unpacked to a list for the UNPACK_SEQUENCE bytecode (i.e. `a, b, c = d`) with unexpected length.)rrrr`rr9rrras_proxyrrrr9rrrrrrr))rrrr@rNrr,rr2s0   z)InstructionTranslatorBase.UNPACK_SEQUENCEc Csd|jkr dksJJ|jd@}|jd?}|}||rnt||}t|||ks3J|d|}||t||}|t||d}t|D]} || qQ|t|t|D]} || qddSt dt ||dgt j ddS)Nrir%z%Failed to unpack object for UNPACK_EXz; cannot be unpacked into a list for the UNPACK_EX bytecode.r) rrrrrrrr)r|r9rrr) rrprefixsuffixrr vals_prefix vals_list vals_suffixitemrrr UNPACK_EXRs,         z#InstructionTranslatorBase.UNPACK_EXz-Encountered intentional debugging graph breakcCs |jrtddddgddSdS)Nz#Forced graph break on leaf functionrzSForced graph break on non-inlining function for nested graph break testing purposeszGSet torch._dynamo.config.debug_force_graph_break_on_leaf_return = Falser)rjr9r+rrrgraph_break_on_leaf_functionjs z6InstructionTranslatorBase.graph_break_on_leaf_functioncCs|jdkr ||dSdS)NGRAPH_BREAK_IF_LEAF)rr7r+rrrrys zInstructionTranslatorBase.NOPcC |dSrrr+rrrr~rFz!InstructionTranslatorBase.POP_TOPcCs(|}|}||||dSrrr)rrarrrrROT_TWOs z!InstructionTranslatorBase.ROT_TWOcCs:|}|}|}||||||dSrr:)rrr<rcrrr ROT_THREEs   z#InstructionTranslatorBase.ROT_THREEcCsL|}|}|}|}||||||||dSrr:)rrr<rr>rrrrROT_FOURs   z"InstructionTranslatorBase.ROT_FOURcCs |}||||dSrr:)rrr<rrrr<s z!InstructionTranslatorBase.DUP_TOPcCs<|}|}||||||||dSrr:r;rrr DUP_TOP_TWOs    z%InstructionTranslatorBase.DUP_TOP_TWOrflagcCsX|dkrtt||giS|dkrtt||giS|dkr*tt||giS|S)NrrrX)rerrrascii)rrrBrrr_convert_valuesz(InstructionTranslatorBase._convert_valuefmt_specr&cCs|}t|tr#ddlm}m}|j||||jd}||dS| ||d@}t d| d}| t tj||gidS)Nr)LazySymNodeFormatStringrvr3rXz{:})rr9rtorch._dynamo.variables.lazyrFrvrrr)rDrgrrrerformat)rrEr&rrFrvfmt_varrrr _format_values   z'InstructionTranslatorBase._format_valuecCs>|j}|dus J|d@dkr|}ntd}|||S)Nr|r)rrrgrrK)rrr&rErrr FORMAT_VALUEs      z&InstructionTranslatorBase.FORMAT_VALUEc Csg}g}i}|jdus J||jD]Y}|r$|d||qt|tjr_||j||j t | t |j @rXt dd|d|d|j dgtjd||j qt dt|d gtjdq|tjd |||dS) Nz{}zBUILD_STRING key conflictzformat_string_parts: z , kwargs: z, part.sym_kwargs: z1Failed to build format string due to key conflictrzBUILD_STRING type errorzLFormat string part type is not correct - expected constant or format string.r)rr*rrr9rStringFormatVariable format_stringrsym_argsrr sym_kwargsr9rrrrr)rr)rrformat_string_partsrrpartrrr BUILD_STRINGs<      z&InstructionTranslatorBase.BUILD_STRINGcCsF|jdks |jdks J|jdkrd}nd}td|d}||dS)Nrriszis notrr)rr'r)rr new_argvalnew_instrrrIS_OPs   zInstructionTranslatorBase.IS_OPc Cs|jdks |jdks J|d\}}|j}z|||d|giWn2tjtfyV}z#t|tr<|jr8| || t |t ||giWYd}~nd}~ww|dkrb||dSdS)Nrrr __contains__)rr*r)rarObservedTypeErrorr:r9r r rrar rA UNARY_NOT)rrleftrightr0rrrr CONTAINS_OPs2  z%InstructionTranslatorBase.CONTAINS_OPcCr)Nrr)rrrr^r9rzrrarrrrrr z%InstructionTranslatorBase.LIST_EXTENDcCs"|tt||gidSr)r)rerrrr+rrr LIST_TO_TUPLEs"z'InstructionTranslatorBase.LIST_TO_TUPLEcCsr|jd}||s J|jtur7tt|tdgi}| |td|| |td|||jd<dSdS)Nrbzgenerator raised StopIterationrHrn) r^rhrgrZrrerrrgro)rrr@new_valrrrSTOPITERATION_ERROR s   z-InstructionTranslatorBase.STOPITERATION_ERRORcCsf|}|jdks J|jdusJ|j|j }t|ts"J|s(J||d|gidSr!) rrrr^rXr9rlrrarrrr DICT_MERGE2s z$InstructionTranslatorBase.DICT_MERGEcCr9rrr+rrr GEN_START=rFz#InstructionTranslatorBase.GEN_STARTcCsH|jd}|r|tt|dS|||dgidS)Nrbr)r^rr)rgrrrrartrrrGET_LEN@s z!InstructionTranslatorBase.GET_LENcCs,|jd}||t|t|gidS)zr If STACK[-1] is an instance of collections.abc.Mapping, push True. Otherwise, push False rbN)r^r)rrar rBrtrrr MATCH_MAPPINGGs  z'InstructionTranslatorBase.MATCH_MAPPINGcCs,|jd}||t|t|gidSNrb)r^r)rrar rErtrrrMATCH_SEQUENCEUs  z(InstructionTranslatorBase.MATCH_SEQUENCEc Cst|d\}}}t|j}||t|t||||git j dkr8|j d}|tt |t dSdS)NrXrrb) r*rgrrr)rrar rCr=rfr^r\)rrsubjectrnamesrrurrr MATCH_CLASS_s     z%InstructionTranslatorBase.MATCH_CLASScCsv|jd}|jd}t|tsJ||t|t||gitj dkr9|jd}|t t |t  dSdS)Nrbrr) r^r9r|r)rrar rDr=rfrgrr\)rrrrrurrr MATCH_KEYSos    z$InstructionTranslatorBase.MATCH_KEYScC||ddS)Nrr)rCr+rrrLOAD_ASSERTION_ERRORrUz.InstructionTranslatorBase.LOAD_ASSERTION_ERRORcCrk)N__build_class__rlr+rrrLOAD_BUILD_CLASSrUz*InstructionTranslatorBase.LOAD_BUILD_CLASSz`Encountered graph break when attempting to trace BINARY_SUBSCR: a binary subscript, e.g. x[attr]cCs,|jdkr||d|_dS|jrJdS)NrF)rappend_prefix_instrar+rrrRESUMEs   z InstructionTranslatorBase.RESUMEcCs|jdusJt|j||Sr)r_binary_op_lookupr+rrr BINARY_OPsz#InstructionTranslatorBase.BINARY_OPcCrrrr+rrrrrz!InstructionTranslatorBase.PRECALLcCsV|jd|j}t|tsJ|D] }t|tsJq|jdus"Jtj|d|_dS)N co_constsr)rrr9rrr rgr)rrr rrrrrs z"InstructionTranslatorBase.KW_NAMEScCs|tdSr)r)rr+rrrrrEz#InstructionTranslatorBase.PUSH_NULLcall_kwc CsP|rtjdks J|}t|tr|sJ|}n |jr$|jjnd}|j dus-J| |j d}tjdkrM|d}t|dt rGgn|dg}nt|dt r[|d}g}n |d}|dg}|r||dt | }|t | d}t t||}t |t |ksJn ||dd}i}z ||||Wd|_dSd|_w)Nrrrrr)r=rfrr9r|rrr rrr*rrrrr) rrrur contentsr%rrrrrr_calls4   zInstructionTranslatorBase._callzTEncountered graph break when attempting to trace CALL: a function call, e.g. f(x, y)cCrNrrwr+rrrrszInstructionTranslatorBase.CALLcCs&|jdusJ||j|j dSr)rr)r^r+rrrCOPYszInstructionTranslatorBase.COPYcCs<|jdusJ|j|j |jd|jd<|j|j <dSre)rr^r+rrrSWAPs.zInstructionTranslatorBase.SWAPcCrrrr+rrrCACHErzInstructionTranslatorBase.CACHEcCrNrrOr+rrr BEFORE_WITHrz%InstructionTranslatorBase.BEFORE_WITHrK>Union[ContextWrappingVariable, GenericContextWrappingVariable]cCst|tr|s|j|tjdkr5|jr'|jr$|jj |jdj ur'd}n|j jdus/J|j jj }n|j }|r^t|t sBt j rQ|jt||t|j|n |jt||t|j||S)Nrrb)r9risupports_graph_breaksr rr=rfr"rrrr(rrrrr^enter)rrKrrrrr enter_ctxs*    z#InstructionTranslatorBase.enter_ctxcCs*tdd|d|dgdddS)NzUnsupported context managerz1Attempted SETUP_WITH/BEFORE_WITH/LOAD_SPECIAL on z%Dynamo does not know how to enter a `z` context manager.)z,Avoid using the unsupported context manager.aEIf the context manager seems like it should be supported (e.g. torch.set_grad_enabled), then it may be the case that it was created outside the compiled region, which Dynamo does not support. Supported context managers can cross graph break boundaries only if they are local non-closure variables, or are intermediate values.zFile an issue to PyTorch. Simple context managers can potentially be supported, but note that context managers can't be supported in generalr)r9r)rKrrrunsupported_ctx_graph_break:s  z5InstructionTranslatorBase.unsupported_ctx_graph_breakcCsZ|}t|ttfs||t|ttfsJ|t||j||||dSr) rr9rhrirr)rkrr)rrrKrrrrPKs z.InstructionTranslatorBase.setup_or_before_withcCs|jsJ|j|dSr)rarbrr+rrrrpZr?z,InstructionTranslatorBase.append_prefix_instcCsLtjdkr|jst|j|jtsJ|jj |j|j<dS| |dSrW) r=rfrar9rXrrrrtrack_cell_newrpr+rrr MAKE_CELL^s  z#InstructionTranslatorBase.MAKE_CELLcCrNrrpr+rrrCOPY_FREE_VARSirz(InstructionTranslatorBase.COPY_FREE_VARScCrNrrr+rrrRETURN_GENERATORlrz*InstructionTranslatorBase.RETURN_GENERATORcCsbtjdkr |n|dtjdkr-|j|}||jvr/|j||jd8_dSdSdS)NrrrWr)r=rfrr*rGrdiscardr)rr current_iprrrrsss       z!InstructionTranslatorBase.END_FORcCsDt|j|jdtrtd|jd|jgtjd||dS)Nz)LOAD_FAST_CHECK on uninitialized variablez/Attempted to load uninitialized local variable r) r\rXr1rrr9rrrr+rrrLOAD_FAST_CHECKs z)InstructionTranslatorBase.LOAD_FAST_CHECKcCs6|j|jvr |tn||t|j|j<dSr)rrXr)rrr+rrrrcs  z-InstructionTranslatorBase.LOAD_FAST_AND_CLEARcCsJ|tj|dd|jdusJ|jd@r||dS||jdS)Nrrr)rrrrrr=rr+rrrLOAD_SUPER_ATTRs  z)InstructionTranslatorBase.LOAD_SUPER_ATTRcCs|jdkr ||dS|jdkr||dS|jdkr+|t||dStdd|jd|jdgtj ddS) NrXr}z Missing CALL_INTRINSIC_1 handlerzCALL_INTRINSIC_1 operand: z,No handler implemented for CALL_INTRINSIC_1 z instruction.r) rr`UNARY_POSITIVEr)r|rrr9rr-r+rrrCALL_INTRINSIC_1s      z*InstructionTranslatorBase.CALL_INTRINSIC_1cCs|}|||dSrr:rtrrrEND_SENDsz"InstructionTranslatorBase.END_SENDzpEncountered graph break when attempting to trace CALL_KW: a function call with keyword arguments, e.g. f(x=True)cCs|j|dddS)NT)rurxr+rrrCALL_KWsz!InstructionTranslatorBase.CALL_KWcCs|jjdvsJdS)N)POP_JUMP_IF_TRUEPOP_JUMP_IF_FALSErZ)rrr+rrrrsz!InstructionTranslatorBase.TO_BOOLcCs|j}|dus J|}t|tsJ|}|d@r2tjdks#J||tdgi}||_ nA|d@r:||_ n9|d@rdt|t sEJ|j }t tt|ddd|dddddtd }||_ n|d@rl||_n|d@rs||_||dS) Nrzrr%r|rT)strictr )rrr9rqr=rfrrgrrr)r|rrlrrr`r*r(r))rrr&r%rrannrrrSET_FUNCTION_ATTRIBUTEs0 $z0InstructionTranslatorBase.SET_FUNCTION_ATTRIBUTEcCs||||jdSr)r)rDrrr+rrr CONVERT_VALUErz'InstructionTranslatorBase.CONVERT_VALUEcCs|tdddS)Nrr)rKrgrr+rrr FORMAT_SIMPLErqz'InstructionTranslatorBase.FORMAT_SIMPLEcCs||ddSr)rKrr+rrrFORMAT_WITH_SPECrUz*InstructionTranslatorBase.FORMAT_WITH_SPEC) __enter____exit__ __aenter__ __aexit__cCst|jts Jd|j|j}|dvrN|}t|ttfs$||t|ttfs-J|dkr?|t || |dS|t |d| |dS| ||}||| |dS)Nz*expected LOAD_SPECIAL arg to be set to int)rrr) r9rr_load_special_namesrrhrirr)rjrrkr=)rrrrKrrrr LOAD_SPECIALs(    z&InstructionTranslatorBase.LOAD_SPECIALcCs|t|jdSr)r)rgrrr+rrrLOAD_SMALL_INTrqz(InstructionTranslatorBase.LOAD_SMALL_INT)rrrranycCs0t|jts Jd|||j|jdS)Nz2expected LOAD_COMMON_CONSTANT arg to be set to int)r9rrr)rC_common_constantsr+rrrLOAD_COMMON_CONSTANT)sz.InstructionTranslatorBase.LOAD_COMMON_CONSTANTcCs |jdkrdd|_dSdS)NrcSrNTrrrrrr2rz>InstructionTranslatorBase.is_non_empty_graph..TF)r count_callsrrrrrr/s z,InstructionTranslatorBase.is_non_empty_graphadditional_stack_framesOptional[list[Any]]cCs.|durg}dt|gtt|S)Nr)r traceback format_listrrr)rrrrrformat_frame_summary6sz.InstructionTranslatorBase.format_frame_summarytraceback.FrameSummarycCs(tjt|jdd|jt|jddddS)Nr rF) lookup_line)r FrameSummaryrrrrrrrrAs   z'InstructionTranslatorBase.frame_summarycCs&t|jdd}td}||duS)Nrrz.*torch/nn/modules.*)rrrecompilematch)rrnn_modules_patternrrris_co_filename_from_nn_modulesIs z8InstructionTranslatorBase.is_co_filename_from_nn_modulesr0cCs,|j|t|}tt|tj|Sr) rinstall_global_by_idrrr=rOrr< WEAKREF_ALIVE)rr0r global_namerrrstore_global_weakref_by_idNs z4InstructionTranslatorBase.store_global_weakref_by_idOptional[FakeTensorMode]cCs |jjjSr)rtracing_context fake_moderrrrrUrz#InstructionTranslatorBase.fake_modecheck_fn!Callable[[VariableTracker], bool]ccs*|j}||_z dVW||_dS||_w)zx Strict mode is enabled on a per-VariableTracker level depending on the return value of check_fn(node). N)rh)rrpriorrrrstrict_translation_modeYs z1InstructionTranslatorBase.strict_translation_modercCsF|jdusJ|jdksJ|j|jj|j|jd|j|jdSrG)rr rrrrrrrrrrgsz#InstructionTranslatorBase.speculatecCsTtjdksJ|jdusJ|jd}t}dd|j|t||D}||kS)zDetect if we're at the start of a list/dict comprehension in 3.12+. In Python 3.12+, comprehensions are inlined with a bytecode pattern that precedes BUILD_LIST/BUILD_MAP. rWNrcSrGrrHrIrrrrJ}rKzEInstructionTranslatorBase._is_comprehension_start..)r=rfrrhrr)rrpatternr0rrrrqs   z1InstructionTranslatorBase._is_comprehension_startcCs|tjdksJ|jdusJd}t|jt|jD]"}|j|}|jdkr*|d7}q|jdkr;|d8}|dkr;|SqdS)zPFind the instruction pointer of the outermost END_FOR for current comprehension.rWNrr]rrsrb)r=rfrr`rrr)r nesting_depth search_iprrrrrs    z8InstructionTranslatorBase._find_comprehension_end_for_iprcsNtjdksJjdusJtjd}g}g}g}t}|d}|dkrLj|}|jdkr=|d|j|d8}n |jdvrG|d8}nn|dks'| | }|dkrat dd d gd t fd d t ||D} t | d|D]i} j| }|jdkr|jdkr| d|krj| d} | jdkr| j} | |vr| |vr|| || |jdkr||jqv|jdrt|jtr|jn|jf} | D]} | |vr| |vr|| qqvg|d}|tjkrj|jdkrj|j|d7}|tjkrj|jdks|}|tjkr<j|jdkr<|d7}|tjkr<j|jdks'|tjkrJj|jndd$fdd }d}|drej|j}d}n8|dr|d}d}ddry|dn|}n!|dsddkrd}d}nt dd d!d"gd t||||||d#S)%zDAnalyze comprehension bytecode to determine result handling pattern.rWNrrrc)rzrrbz)Comprehension analysis failed: No END_FORrz=Could not find END_FOR instruction in comprehension bytecode.rc3s$|] }j|jdkr|VqdS)r]N)rrr]rrrrszCInstructionTranslatorBase._analyze_comprehension..ryrtrrrrrcs*|}|dko|dkp|d S)Nrrr)rpat)patternsrrrrmatchess zAInstructionTranslatorBase._analyze_comprehension..matchesrFrrrrrTz)Comprehension analysis failed: No matcheszpre_store_ops=z, post_store_op=z8Comprehension does not match any known bytecode pattern.)rrrrrr)rrrr)r=rfrrrrrinsertrrrr9rr`rrrrMr9rrr)rstart_iprrrdefined_inside iter_scan_iprr for_iter_ipbody_ip next_instvar_name var_namesscan_ip store_fast_iprrrr)rrrrr_analyze_comprehensions                    z0InstructionTranslatorBase._analyze_comprehensioncstjdksJ}jjtr |jr tdt |jdgdj dus'Jj d}dt |j t dg}tdjj|d }fd d tD}|d }tjj}td d|D} t jt |j} |gt| d|d |ttD]} |td|| r|| q|t!dddgq|t!dg"|||| |\} } |gt| d|d |t!dddt| d|d |t!ddd#| g| g|| d kr8| dd}|gt||d |t$|| |dt!dddt!dt!d|j%|j&rB|j&gng}i}|D] }t'j(|<||j)vr`|j)|||<qIt |j)|j)|<qI| d}|j%r|gt||d |t*|j%D]>\}}|gtd||d|||vr|gtd|||t!dq|t!dddgq|t!d|d |g|j+r,t'nH|j&r"|gt||d ||j&|vr||||j&t!dgn|gtdt!dddt!dn|t!dgj-|.j/|j0}j-1||d_ dS)zHandle list/dict comprehension graph break. Builds a synthetic function wrapping the comprehension bytecode, calls it via codegen_call_resume, then chains into the resume function for the post-comprehension code. rWzDComprehension graph break in resume function with captured variableszCannot use comprehension optimization inside a resume function when there are captured variables. This can cause issues with deeply nested source chains.rNrcomprehension_graph_breakzcomprehension triggered compilercs*g|]}tjtj|tqSr)r9r^rrr]rrrrrJ:szOInstructionTranslatorBase._handle_comprehension_graph_break..rcss|]}|sdVqdS)rNr)rmrrrrGrzNInstructionTranslatorBase._handle_comprehension_graph_break..rrrrrdrrr)2r=rfrrrrMrKrr9rrrrr>rr rrrr`r*r1rror^rrr%rrrr*pop_nullr'_build_comprehension_fnrr&rrrrXrrRrr)rrQrrr)rranalysisrrrstack_pops_null_maskrr nonnull_countlive_stack_depthrNrr'frame_values_pos vars_to_pass existing_varsrfv_depthr walrus_varrrrrrs^                           z;InstructionTranslatorBase._handle_comprehension_graph_breakrrrr list[bool]rc sZddlm}ddlm}ddlmmt fdd|jD} ddgt | d d t Dtt t j j p9gt j jp@g jd urM jn j jtd j jd jjjrijgngjd f dd } | j | \} } || | jr j| | fS jt| j| fS)aBuild a synthetic function wrapping comprehension bytecode. Uses the same calling convention as resume functions created by create_resume / ContinueExecutionCache.generate: the first two args are __nested_resume_fns and __nested_frame_values (ignored here), followed by stack items and live locals. Returns (code, name) where name is the global name for the function. r)transform_code_objectr) CO_VARARGSCO_VARKEYWORDSc3s |] }|vr|VqdSrr~rrrrrszDInstructionTranslatorBase._build_comprehension_fn..__nested_resume_fns__nested_frame_valuescSsg|]}d|qS)___stackrr]rrrrJr3zEInstructionTranslatorBase._build_comprehension_fn..N__comprehension__at_rrrrrrcs|d<tjdkr |d<|d<d|d<|d<t|d<d |d <d |d <tfd d D|d<|dB@|d<g}rP|tdtd|tdd dd}t D]} |ro|tdqa|tdd|d|d8}qa  j}g}j sj r|tdj dn |tdddj rÈj D] }|td|dq|tddtj d|td||||dd<dS)Nrrr$co_firstlinenorrwrz co_argcountrco_posonlyargcountco_kwonlyargcountcsg|]}|vr|qSrr)rrrrrrJ:zUInstructionTranslatorBase._build_comprehension_fn..update.. co_varnamesco_flagsrrrqrrrrrrrrq) r=rfrrrr'r`_copy_comprehension_bytecoderrrr)rrr0 nonnull_irN comp_instsepiloguer rrrrcomprehension_body_varsr'r{rrrrrrrrr-s\        zAInstructionTranslatorBase._build_comprehension_fn..update)rrrrrr)bytecode_transformationrrrresume_executionrrrrrr`sortedrrwrzrrr/rrrrrrrr:rr) rrrrrrrrrrrrrrrrrsP   &?z1InstructionTranslatorBase._build_comprehension_fnrcCsri}g}t||D]}|j|}t|}d|_|||<||q |D]}|jdur6|j|vr6||j|_q$|S)z@Copy comprehension bytecode instructions, updating jump targets.N)r`rr!r"rr)rrrinst_map copied_instsr original_inst copied_instrrrrzs    z6InstructionTranslatorBase._copy_comprehension_bytecoderfallback_linenotuple[str, int]cCs |dus|dkr ||fS||fSrr)rrrrrrr_make_frame_locsz)InstructionTranslatorBase._make_frame_loc frame_loctuple[tuple[str, int], ...]cCsbg}tjr$|j}|dur$||jj|j|jj}|||j}|dus | ||t |Sr) rrrrrrrrrreverser)rrframe_loc_chain_list current_txparent_frame_locrrr_get_frame_loc_chains  z.InstructionTranslatorBase._get_frame_loc_chainrrrUnsupported | StepUnsupportedc s|jrdSt|dd}|durtjj}z$tjr+|jdur+| |j j |j |j j }n | |dj|dj d}WntyJ|d|df}Ynw||}d}tjrat}dt|}n t|}t|}dt|} |dur{t||}d|dd|d d |d tjr|d | d 7nt| 7tjjdddfdddt|tr|jnt|} t t!j"rt#st$%| |frtjrڈd7d|j&d7t'n t'd|d|d |d|_dS)NrrbrrrrzGraph break in user code at rrz Graph Break Reason: z User code traceback: zQ ========== most recent `torch.compile` tracing attempt started here ========== a} NOTE: the most recent `torch.compile` tracing attempt might not be where you applied `torch.compile`! This is due to how graph breaks are implemented - the optimized code object returned by Dynamo will call another Dynamo-generated resume function and tracing is re-enabled by calling the resume function as a normal Python function, which Dynamo intercepts as a top-level frame. artifactcSs dddS)Ndynamo_graph_break_reasonstring)rencodingrrrrrrsz;InstructionTranslatorBase.log_graph_break..csdtS)Nr)r format_excruser_stack_tracerrrrK) metadata_fn payload_fnz4 Most recent bytecode instructions traced (max 20): rzmGraph break (user stack suppressed due to duplicate graph break) in user code at %s:%s Graph Break Reason: %sT)(loggedrrrirrjrrrrrrrrr IndexErrorrrr6rrrr4r2r_loggingtrace_structuredr9r:rrgraph_break_log isEnabledForrDEBUGexplainr[rror) rrrr user_stackrframe_loc_chainstack_above_dynamo_formattedstack_above_dynamouser_stack_formattedrrr rrs           z)InstructionTranslatorBase.log_graph_breakrtypes.CodeTyper:cCs(tddt|dgtj|dddS)Nzgraph break in loopzframe skipped: ztorch.compile detected a graph break in a for/while loop. Skipping the frame and falling back to eager, as graph breaks in loops are not supported.T)rrrrrr )r9r5rr )rrrrrrs  z0InstructionTranslatorBase.raise_loop_graph_breakrrrrrexportr rdistributed_stateOptional[DistributedState]r)Optional[tuple[types.CellType]]rG Optional[dict[Instruction, int]]cst||_||_||_||_||_| |_| |_d|_ g|_ d|_ d|_ t d|_d|_g|_g|_d|_d|_d|_g|_||_tdd|_d|_t|_||_|durY|nt|j|_||_||_ ||_!||_"| |_#||_$|durt%j&rt'| ||d|_(nd|_(i|_)i|_*| |_+d|_,d|_-d|_.d|_/d|_0d|_1d|_2d|_3g|_4||_5d d l6m7}m8}m9}m:}| j;||B|B|B@r|d|_?dgt@| jA|_BtCDtEjF|_GtHDtEjF|_ItJK| jL|dS) NrrTrb)maxlen)rr)rFr)CO_ASYNC_GENERATOR CO_COROUTINE CO_GENERATORCO_ITERABLE_COROUTINE)Mr5r6r rrrXrYrZr[r\r^rrir'r`rrr rr rarbrfrrorrrrrrGrrrrrr)rreplay_record_enabledrGrgnn_module_stack num_callsrr rrrerhrjrrkrlrnrr$r%r&r'rr)rercrdrrtrrrrrrrrr lazycacher)rrrrrrrrXrYrZr[rrrcr rfrr)rnrGr$r%r&r'r7rrr6#s      z"InstructionTranslatorBase.__init__rrrrA)r%rarr]rrWrr)r%rnrrrrWrra)r%rnrrrrWrrr)rr_rrr)rrrrrr,rr)rr,)rr,rrrr)r@rrr)rr]rrrra)rrrr])rr,rra)r rrrN)rrrnrr#rrr)rrrra)rrDrr)r@rarra)rrrr)r@rarr)r@rarry)rrrr)rrrr)rr,rrrr)r~rrr,rr@rrrr1rrrrrrrr,rrrr)rrrrArr1rr)rr,rr)rr,rrrr)rrarBrrra)rErar&rrr)F)rr,rurrr)rKr}rr,rra)rKrarr)rrrr)rr)r0rrrrrrr)rrrr)rrr)rr)rrrrrrrrrrrr@rr)rrrrrr)rrrr_rrrr)rrrr)rrrrrrrr)rrrr:rr)NNN)(rr?rrrrrrrrrrrXrWrYrWrZrr[rrrrrrcrr rrfr:rrr)r rnrmrGr!rr(rrrrrprryr{r}rrrrrrrwrr=rfrpropertyrrrrr)rrr*rrrtrr LOAD_CLOSURErrr r3cached_propertyrrrrr r(r0r;EAGER_IMPORT_NAMEr>rCrr JUMP_FORWARD JUMP_ABSOLUTErrnot_rrrJUMP_IF_FALSE_OR_POPJUMP_IF_TRUE_OR_POPrJrLrMrQrRrSrTrVr]r^rdrmrOrvrsrhrrrrrrrrrr(rrrrrrrr=rrr staticmethodrrrrrrrrrrr rdrrzrrBUILD_TUPLE_UNPACK_WITH_CALLrrBUILD_MAP_UNPACK_WITH_CALLrrrr"rr+rr6r7rrr=r?r@r<rArDrKrLrSrWr]rr^r`ra DICT_UPDATErbrcrdrfrirjrmror5r|rnegUNARY_NEGATIVErZinvert UNARY_INVERTpow BINARY_POWERmulBINARY_MULTIPLYmatmulBINARY_MATRIX_MULTIPLYfloordivBINARY_FLOOR_DIVIDEtruedivBINARY_TRUE_DIVIDEr6 BINARY_MODULOBINARY_REMAINDERr BINARY_ADDsubBINARY_SUBTRACTgetitem BINARY_SUBSCRlshift BINARY_LSHIFTrshift BINARY_RSHIFTand_ BINARY_ANDor_ BINARY_ORxor BINARY_XORipow INPLACE_POWERimulINPLACE_MULTIPLYimatmulINPLACE_MATRIX_MULTIPLY ifloordivINPLACE_FLOOR_DIVIDEitruedivINPLACE_TRUE_DIVIDEimodINPLACE_MODULOINPLACE_REMAINDERiadd INPLACE_ADDisubINPLACE_SUBTRACTilshiftINPLACE_LSHIFTirshiftINPLACE_RSHIFTiand INPLACE_ANDixor INPLACE_XORior INPLACE_ORrqrsrrrrwrryrzrJUMP_BACKWARD_NO_INTERRUPTPOP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUEPOP_JUMP_FORWARD_IF_FALSEPOP_JUMP_BACKWARD_IF_FALSEr{r|rrrPrprrrrsrrcrrrrrrrrrLOAD_FAST_BORROWrPOP_ITERrrrrrrrrrrr contextlibcontextmanagerrrrrrrrrrrrrr6r9rrr7rrs    #       q .  E  J     #       >                    / "    &    S   @     D*s#    '     !                                     /    %    !   gn$) metaclasscseZdZed6ddZejd7ddZd8fd"d# Zd9d$d%Z d:d(d)Z d;d*d+Z d9d,d-Z drrrrrrr#rrrrrr_returnsZ     zInstructionTranslator._returncCrNrrr+rrrrqrz"InstructionTranslator.RETURN_VALUEcCrNrrr+rrrrrrz"InstructionTranslator.RETURN_CONST)rr(r.)$rrrrrrrrrrr)rrrrrrrr rrrrrrrr rrfr:rrrnrmrrr)rrSrrrr-)rrrr;rrrrr6rrrrrrqrrr9rrr7rr(s   &    /r(rcCs<g|]\}}ttd|vr|ddnd|ddqS)INPLACErXNBINARY_)rr()rrrrrrrJs$rJrr?rrget_inline_depthCallable[[], int]c cstjs dVdS|jdurt|_|j}|j}|j|j|j|j t d}z]dVd}W|j }t }|r|dur|}||j } | |j} t|j|j|j| | t|j||rc|dnd|rj|dnd|rq|dnd|j|d } |j| |j| dSdSdS|j }t }|r|dur|}||j } | |j} t|j|j|j| | t|j||r|dnd|r|dnd|r|dnd|j|d } |j| |j| www)a[ Context manager for profiling inline calls. Args: output: The OutputGraph containing profiler_state code: The code object being inlined (for timing metadata) get_inline_depth: Callable that returns inline_depth (called after work completes) Yields: None (profiling happens around the with block) NFTrrr) func_namer firstlineno cumtime_ns tottime_nsbytecode_countrccaller_func_namecaller_filenamecaller_firstlinenois_primitive_call call_stack)rdynamo_profilerprofiler_stater get_current_callerget_call_stackr)rrrtimetime_nsr start_time_ns child_time_nsr rrrrco_coder record_timingadd_child_time) rrr caller_infor trace_success stack_entry trace_end_nsrcrrtimingrrrprofile_inline_callsz             rcseZdZUdZded<ded<edCddZedDddZedEddZ dFddZ dGfd#d$ Z e dHd&d'Z dId(d)ZdJd+d,ZdJfd-d. ZdKfd4d5 ZdLd6d7ZdLd8d9ZdMd=d>ZdLfd?d@ ZdLfdAdB ZZS)Nrz Trace and inline a called methodrsymbolic_resultrrrfuncrnrrrrWrracsZd}tj|fdd||||}|WdS1s&wYdS)Ncs jdSrQrcrrrrr!s z;InliningInstructionTranslator.inline_call..)rrrbuild_inline_tracer inline_call_)rrrrrtracerrrrrs$z)InliningInstructionTranslator.inline_calltrace_rules.SkipResultc CsF|rtdt|dgdt|tr;t|ddr;t|dd}tdt|d|d |d d gdtj |d d }|j rddl m }t |drbt |jdrb|jj|urbtddSt |drk|jjnd}d|dg}d|vr|d|ddg7}tdd|d|d|d|jd|d |d|S)!NzInline attempt with __self__zAttempted to inline a function with the `__self__` attribute. Dynamo is expected to decompose method calls into function calls with a `self` argument.r_torchdynamo_disableF_torchdynamo_disable_msgz2Skip inlining `torch.compiler.disable()`d functionzSkip inlining function z= since it was wrapped with `torch.compiler.disable` (reason: rz(Remove the `torch.compiler.disable` callT)is_inlined_callr)!produce_trampoline_autograd_applyr%_originz"allowlist in dynamo known functionrzAvoid calling the function `r,rz:Apply `@torch._dynamo.dont_skip_tracing` to the function `zw` to force tracing into the function. More graph breaks may occur as a result of attempting to trace into the function.z Please file an issue to PyTorch.z.Attempted to inline function marked as skippedz qualname: z, name: z , filename: `z`, skip reason: z?Dynamo developers have intentionally marked that the function `z` should not be traced.)has_selfr9rr9rsr0r get_functionr check_verboseskippedtorch._dynamo.variables.miscrrr%r SkipResultr get_filenameget_namer)rrCrjr fn_qualnamerrrrcheck_inlineable&sh             z.InliningInstructionTranslator.check_inlineablecst|tttfs J|d}jj}tjs$|r$|j d}r$|}|dur>t |}|j dus4Jtjs>|r>||j <d}z |||}Wn?ty}z3tdd|d|d|jddd|Dd | d |d gtj|d WYd}~nd}~ww|dusJt|D]} t| tstd d|d| dgtjdqjdvr|rt|dtjstddjd|djdgdd} tjj j!"drdt#$#} t%j&dkrj'j(d$fdd } t)*d!t+| t,*d"| |j-|r5t|dt.r5j/|dj0} t| tj1j2r5t34| t56| j7j8d#<|rYt|dt9rY|dj:} t| tj1j2rYt34| t56| j7j8d#<t|t;raJt<rut=|j>j?j@|} | St |j>j?j@|} | S)%NFz2failed to bind arguments when attempting to inlinezfunc='z' rz ; args = cSsg|]}|qSr)r)rrrrrrJrzEInliningInstructionTranslator.build_inline_tracer..z ; kwargs = z4Argument mismatch when attempting to trace function r8rz:Encountered unconverted argument when attempting to inlinezfunc: z, arg: zWAn argument to an inlined function was not successfully converted to a VariableTracker.r)rr_rz2Unsupported __setitem__/__setattr__ inline attemptz code name: z, args: zAttempted to inline z: where first argument (self) is not a user-defined object.rbytecoderrrrcs6jjjd}t}djd|d|S)N)rzTRACE inlined call z from r)rrxrrYrr)headerrrcur_instr parent_coderrget_trace_call_log_strs zQInliningInstructionTranslator.build_inline_tracer..get_trace_call_log_strrzINLINING %s%s, %srr)Ar9rsrqrorrrrdont_skip_tracingpreviously_inlined_functionsr1rrr bind_argsrr9rrrrrrrrrarrrrrr _internal log_stateis_artifact_enabledrPBytecoder=rfr`rtrace_call_logrr]r rrrrrrrrr0rforwardrvrrrrr-&InliningGeneratorInstructionTranslatorrYrZr[)rrrrrj tracing_ctxprevious_result sub_localsrrr1rmodulerrrrrhs    "           z1InliningInstructionTranslator.build_inline_tracerc Cs|j}d|_d|_|j}t}|jr||j}zYz| |Wdn1s,wYWn7t j yM}zd|d|}t |d}~wt y\}zd|_d}~wtyit d|wW|j|_d|_n|j|_d|_w|jjrtS|jdusJ|j|jur|j|j|j|jO_t d||jjj|tjst|tr|j rt!|rt|tr|j"rt|tsJg}|j#s|jg}t j$t%||ddS|jSt!|rt|tsJ|j#sJt&|j't(dS|jS) NFTz!Observed exception DURING INLING z : zFAILED INLINING %szDONE INLINING %srr ))rrjrkrr nullcontextrhrrrrr rr:r rrrrrfrrrYrrdr traced_coderrrr9ris_generator_from_ctx_managerr-generator_exhaustedis_constant_nonerrZrygenerated_itemsr`)rrr strict_ctxrrCrrrrrs~        z*InliningInstructionTranslator.inline_call_rrrXrYrZrr[rfuncvar7BaseUserFunctionVariable | LocalGeneratorObjectVariablercsZ|}|d} t| ts| j} |jj} | r| jnd} | dur,| j} | j } | j }n"t } t | t | } fddtD}| rNt| | |d| j<tjdid|jdid|d| d |d |d |d |d | d|dd|jd|jdd|jd|jd|jd|jd| ||_||_|j|_d|_|j|_|j|_dS)N __builtins__csi|]}|t|qSr)rrrrrrWrz:InliningInstructionTranslator.__init__..)rrGrrrrrrXrYrZr[rrrrrcrr rfrrnrGr) get_globalsr9r__dict__rrinlined_code_cacher1rrGrr!r rr+rr5r6rrcr rfrrnrrr*rr)r!r )rrrrXrYrZr[rrrrcachedrrGrr7rrr6;s~          z&InliningInstructionTranslator.__init__rcCs|jjSr)rrrrrrrzsz'InliningInstructionTranslator.fake_modecCst|jSr)rrrrrrrrr~rEz)InliningInstructionTranslator.run_ctx_mgrrcCs*tjsdS|js dS|jsdSdS)zCheck if comprehension speculation is allowed in this inlined context. Unlike should_compile_partial_graph(), this skips the exception table entry check. FT)rrr should_allow_nested_graph_breaksrrrrrrrs  zAInliningInstructionTranslator._can_speculate_comprehension_nestedcs0tjr|js dS|jsdStSdSr)rrrr rrr5rr7rrrs   z:InliningInstructionTranslator.should_compile_partial_graphrr,rrrcs(tjr t||StdddgddS)NzGraph break in inlined functionrz2Graph breaks in an inlined call are not supported.r)rrr5rr9rr7rrrs z3InliningInstructionTranslator.create_call_resume_atcCs||_d|_tr)rrrr#r+rrrrqs z*InliningInstructionTranslator.RETURN_VALUEcCs|||_d|_tr)rrrr#r+rrrrrs z*InliningInstructionTranslator.RETURN_CONSTrr#tuple[Any, VariableTracker, Source]c Csd|jvr4|jdds4|jd}||}d|vr#tjjj|}nt|}t|||}t ||}n|j d|j}t |}|j}t|||}t ||}t|rWt|}|||fS)Nr namedtuple_r___unnamed_scope)rrMr rrnrrrrcrLrrrNrMr?rR) rrr rr fglobals_vt global_source globals_nameglobals_sourcerrrget_globals_source_and_values.     z:InliningInstructionTranslator.get_globals_source_and_valuecs|j}||jvr ||S|jj|jurt|dS||\}}}|jj ||r9| |jj ||dS|j|}| t |||dSr)rrrrr r5r rrhas_pending_mutation_of_attrr) load_attrrar )rrrrrrrr7rrr s   z*InliningInstructionTranslator._load_globalcsn|jj|jurt|dS|}t|tr!td|j dgd|j }| |\}}}|jj |||dS)Nz3Storing Tensor hook handle in globals (inline call)rr) rr rr5rrr9rr9rrr store_attr)rrrr_fglobals_valuerrr7rrrs z*InliningInstructionTranslator.STORE_GLOBAL) rrrrnrrrrWrra)rrnrr) rrrrnrrrrWrrr/)rrrrrXrWrYrWrZrr[rrrrrr1r.rr0r-)rrrr )rrrrrrrr;rrrr6r2rrrrrrqrrrr rr9rrr7rrs0   A  M?       *rcseZdZUded<dfdd Zdfd d Zd ddZd!ddZd!ddZd!fdd Z d!fdd Z d!ddZ d!ddZ Z S)"rr]rrrrrrcs(tj|i|g|_d|_d|_dSr)r5r6rrr)rrrr7rrr6s z/InliningGeneratorInstructionTranslator.__init__racsFtjjfdd tWdS1swYdS)NcsjSrrrrrrrszEInliningGeneratorInstructionTranslator.inline_call_..)rrrr5rrr7rrrs$z3InliningGeneratorInstructionTranslator.inline_call_rcCrrrrrrrr szCInliningGeneratorInstructionTranslator.should_compile_partial_graphrr,cCsL|}|j|t|jtkrtj|tt j s|j r$||_ t dSr)rrrrrurInfiniteGeneratorErrorr)rfrrrrr$)rrtoprrr YIELD_VALUEs  z2InliningGeneratorInstructionTranslator.YIELD_VALUEcCsB|jd}t|ts|tt||gi}||dSdSre)r^r9ryrrerrr))rrruresrrrGET_YIELD_FROM_ITERs  z:InliningGeneratorInstructionTranslator.GET_YIELD_FROM_ITERcd|_t|Sr)rr5rqr+r7rrrq$ z3InliningGeneratorInstructionTranslator.RETURN_VALUEcrr)rr5rrr+r7rrrr(rz3InliningGeneratorInstructionTranslator.RETURN_CONSTc Cst|jdks J|}|jd}|stdddgdz||}Wn.ttjfyS}zt |tjr;t ||| t |jWYd}~dSd}~wwt |jtr_|jdksaJ|jd8_| |||dS) NrrbUnreachable sub-generator coder@Should only be encountered while implementing generator support.rrr)rr^rrr9rYrZrr[r9rr)rgrrrrrrrr@ruexrrr YIELD_FROM,s2      z1InliningGeneratorInstructionTranslator.YIELD_FROMc Cs t|jdks J|}|jd}t|ttfs&t|trpt|jtj j rp| rfz| |}Wn-t tjfy^}ztjdkrE||t|j||WYd}~dSd}~ww||dStdddgddStdd t|d t|d gddS) NrrbrWr rr!rzSEND with bad typez TOS type: z(Attempted to SEND with unsupported type r8)rr^rr9rxrprr collectionsabcIteratorrrYrZrr[r=rfr)rgrrr9r_r"rrrSENDRs>      z+InliningGeneratorInstructionTranslator.SEND)rrrrrrr/rr-)rrrrr6rrrrrqrrr$r(r9rrr7rrs     &r)rrrr)rr)rrrr )r%r&rr')r6r7rr)r@rrrAr,)rri)rrrrr)rrr)rrr)rrr)rrrr1rrrr)r)rrrrr)rr?rrrrrr ( r __future__rr%collections.abcrr!rrPr3rr0rrrrrr= threadingrrr:rrtypingrrrrrr r typing_extensionsr rtorch._loggingtorch._dynamo.dynamo_profilerr r torch._dynamo.excrr torch._guardsrrrtorch._logging.structuredr%torch.fx.experimental.symbolic_shapesrtorch.utils._functoolsrrrrrrrrbytecode_analysisrrrr rr!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0codegenr1r2r3r4r5r6r7r8r9r:funcname_cacher;guardsr<r= output_graphr>r?r@ polyfillsrArBrCrDrE replay_recordrFrGrrHrIrJrKrrLrMrNrOrPrQrRrSrTrUutilsrVrWrXrYrZr[r\r]r^variables.baser_r`ravariables.builderrbrcrdvariables.builtinrevariables.constantrfrgvariables.ctx_managerrhrirjrkvariables.dictsrlrmvariables.functionsrnrorprqrrrsrtvariables.iterruvariables.lazyrvvariables.listsrwrxryrzr{r|variables.miscr}r~rrrrrvariables.nn_modulerrvariables.streamsrvariables.tensorrrvariables.torch_functionrrvariables.user_definedrrrrrrrrtorch._subclasses.fake_tensorrrnr getLoggerrr rgetArtifactLoggerrrrrrrrrrcontainsrrr8rrcacher dataclassrrrrrr rr rrrrrr#r$r5r?rVrhrrrrrrr(rr)r:rr(rf_nb_opsrrrrrrrrrsd  $     D  , ( ,  $  $            F     $     A * !  ! bq$ =p