o j9:j@s$UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZddlmZmZmZmZmZmZddlm 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 l/m0Z0dd l1m2Z2d dl3m4Z4m5Z5m6Z6mZ7m8Z8m9Z9d dl:m;Z;mZ>d dl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNd dlOmOZOd dlPmQZQd dlRmSZSd dl5mTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]d dl^m_Z_d dl`maZambZbd dlcmdZdmeZemfZfd dlgmhZhmiZimjZjmkZkmlZld dlmmnZnmoZod dlpmqZqmrZrmsZsd dltmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|d dl8m}Z}m~Z~d dlmZmZmZmZmZmZmZmZmZd dlmZmZmZd dlmZmZmZd d lmZmZd d!lmZd d"lmZmZmZmZd d#lmZd d$lmZmZmZmZmZmZmZd d%lmZd d&lmZd d'lmZmZmZmZmZmZd d(lmZmZmZmZmZmZmZd d)lmZmZd d*lmZd d+lmZd d,lmZmZmZd d-lmZmZd d.lmZmZmZmZmZer<e9jeBeBZd?ed@<e jddEdFZejGdGdHdHZejGdIdJdJZejGdKdLdLZejGdMdNdNZGdOdPdPZe jddRdSZejddWdXZejddYdZZejGd[d\d\ZGd]d^d^eZGd_d`d`eZGdadbdbeZddfdgZddkdlZe jddodpZddudvZdwZddzd{ZddddZdddZdddZdddZGdddeZejGdddZGddUdUedZGdddeZejdkrsddej DZ ejdddZ 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)AnycastNoReturn TYPE_CHECKING TypeAliasTypeVar)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)%maybe_setup_comprehension_speculation) !augment_exc_message_with_hop_nameBackendCompilerFailedcollapse_resume_framesformat_frame_infoget_stack_above_dynamoResumePrologueTracingErrorStepUnsupported unimplemented Unsupported UserError) 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 ReenterWith) 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)BuiltinVariableDictBuiltinVariable)ConstantVariable)ContextWrappingVariableGenericContextWrappingVariableWithEnterFunctionVariableWithExitFunctionVariableConstDictVariable)BaseUserFunctionVariableLocalGeneratorFunctionVariableLocalGeneratorObjectVariableNestedUserFunctionVariableSkipFunctionVariableUserFunctionVariableUserMethodVariable)MAX_ITERATOR_LIMIT)LazyVariableTracker)BaseListVariableIteratorVariableListIteratorVariable ListVariable SliceVariable TupleVariable) CellVariableExceptionVariableGetAttrVariable NullVariablePythonModuleVariableTracebackVariableUnknownVariable)NNModuleVariableUnspecializedNNModuleVariable) SetVariable)SymbolicStreamState)supported_comparison_opsSymNodeVariableTensorVariable)SymbolicTorchFunctionStateTorchFunctionModeVariable)RemovableHandleVariableUserDefinedClassVariable!UserDefinedExceptionClassVariable"UserDefinedExceptionObjectVariableUserDefinedObjectVariable)Callable GeneratorSequence)FakeTensorMode)CompilePackage graph_breaks trace_call trace_sourcetrace_bytecodecCsi|] \}}|t|jqS)re call_function.0kvrre/home/nk/hobo-godmode/plappi-mvp/.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_failedNz bool | Noneerror_on_graph_breakzGraphCompileReason | NonereasonrNonecCs0d|_||_|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)rrrrrfailed s zSpeculationEntry.failed)rrrr)rrrr) __name__ __module__ __qualname____annotations__rrrrrrrrrrs      rc@s|eZdZUdZejedZded<dZ ded<dZ d ed <ejedZ d ed <dZ d ed <dddZ dddZdddZdS) 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_grad list[str]autograd_grad_leaked_tensorsgraph_break_on_requires_grad_rrcCs 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__ dataclassesfieldlistrrrrrrrrrrrrrrs      rc@s,eZdZUejedZded<d ddZdS) LocalStaterzdict[str, FrameStateSizeEntry]automatic_dynamicrrcCsddd|jDS)N css&|]\}}|d|VqdS): N)renderrrrr es z$LocalState.render..)joinritemsrrrrrds zLocalState.renderNrr) rrrrrdictrrrrrrrr^s rc@s*eZdZUded<ded<dZded<dS)DistributedStater compile_pgr local_stateNzlist[LocalState] | None all_states)rrrrrrrrrrks rc@sTeZdZUeZded<edddZedd d Zedd d Z edddZ dS)TensorifyStatezset[str]force_specializationsrrrrcC|j|dSr)raddclsrrrr specializexszTensorifyState.specializercCs ||jvSr)rrrrrshould_specialize| z TensorifyState.should_specializecC|jdSr)rrrrrrrzTensorifyState.clearcCst|jdkSr)rrrrrremptyrzTensorifyState.emptyN)rrrr)rrrrrrr) rrrsetrr classmethodrrrrrrrrrrs    rCallable[..., None]cCs ttSr)torchdynamo_loggingget_step_loggerlogrrrr _step_loggerrrrrGenerator[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   rccs2z|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_indexNz?ContextWrappingVariable | GenericContextWrappingVariable | None with_contextrrcCs |jduSr)rrrrr can_restorerzBlockStackEntry.can_restorerKcCsN|jdusJ|jr t|jdr |jjr t|jdt|jjSt|jdS)N target_valuesr)rrhasattrrrKtuplerrrr resume_fns zBlockStackEntry.resume_fnrris_graph_breakVariableTracker | NonecCs0|jdusJ|r|js|s|j|SdSr)rexit_on_graph_breakexit)rrr!rrrr$s zBlockStackEntry.exitr)rrK)rrr!rrr")rrrrrrr r$rrrrrs     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*r4rr1rstack_ops r:modobjectrcCs&t|tjsdS|jddtjvS)NF.r) isinstancetypes ModuleTypersplitsysstdlib_module_names)r;rrr is_stdlibs rDwith_msgrcCsb|rddd}nddd}dd t|D}td d t|D}|d }||d |d S)NxrrrcSs|sJddS)NmsgrrFrrrr*z(get_assert_bytecode_sequence..fncSs |sJdSrrrHrrrr* cSg|]}|jqSrrrrrrr z0get_assert_bytecode_sequence..css"|] \}}|dr|VqdS)POP_JUMPN) startswith)rirrrrrs z/get_assert_bytecode_sequence.. RAISE_VARARGSr)rFrrr)disget_instructionsr enumerater)rEr*insts begin_idxend_idxrrrget_assert_bytecode_sequences   rZrtruth_fnCallable[[object], bool]r.c Cs|tjus|r dSt|jtsJ|j}dD]:}t|}|j||t|}dd|D}||krP|rB|d}|j||j }nd}| t ||dSqdS)NF)FTcSrKrrLrMrrrrN rOz:_detect_and_normalize_assert_statement.. LOAD_CONSTzassertion errorT) operatortruthr>rrrZ instructionsrrargvalr.rabuild) rr[r.current_instruction_pointerrE assert_insts cur_instsload_const_idx error_msgrrr&_detect_and_normalize_assert_statements2  rhFn torch.fx.NodecCs|jddp t|dd}|sdS|d}d}t|D] \}}|dr+|}q|dkr2dS||}d}|dt|krJ||d}||rTd|SdS) zIExtract the innermost user source location from an FX node's stack trace. stack_tracerrzFile rrz, code: )metagetgetattrstriprArVrQr)rist trace_lines last_file_idxrRline file_linecoderrrget_node_source_infoPs  rwvaluera max_linesrcst|tsdSzK|jj}ggtddddfd d |s/s/WdSg}ttD] }|||dq9d d dd|DWSt yct j dddYdSw)zWalk the FX graph backwards from a TensorVariable to show how it was computed, with user source locations. Graph inputs (placeholders) are always shown first, followed by operations in dataflow order ending at the branch condition.rar<rrcSst|tjjr |jSt|Sr)r>torchfxNoderrepr)r{rrrfmt_argssz0format_tensor_computation_trace..fmt_argrirjrcs|jvrdS|jt|}|jdkr6g}|r"|d|||jd|jd|dS|jdkrtkrt|jdt|j}d fdd |j D}g}|rd|d|||jd |d |d||j D]}t |t j jr|q{dSdSdS) N placeholderz# z: graph input ()rrz, c3s|]}|VqdSrr)rr{)rrrrz@format_tensor_computation_trace..walk..z = r)rrrwoprrrrorrrr>r|r}r~)risourceblock target_nameargs_strr{rrz op_blocksplaceholder_blocksvisitedwalkrrrvs2       z-format_tensor_computation_trace..walkz@ The branch condition involves a tensor computed as follows: rcss|]}d|VqdS) Nr)rrtrrrrsz2format_tensor_computation_trace..z&format_tensor_computation_trace failedT)exc_infoN)r{r<rr)rirjrr) r>rproxynoder rrextendrr Exceptionrdebug)ryrzr all_linesrrrrformat_tensor_computation_tracecs0     r8Callable[[InstructionTranslatorBase, Instruction], None]cs6ddd ddfdd dfdd }|S)NryrarrcSst|}g}t|tr9z$|jjjd}|dur.|dkr.|jt j t j t j fvr.| dWn ty8Ynw|tj| dtdd|d||ddS) N example_valuerzThe branch condition uses a scalar integer tensor. Consider rewriting the computation to use plain Python ints (e.g. use int attributes instead of tensor buffers) so the condition becomes a shape guard instead of data-dependent branching.z1Use `torch.cond` to express dynamic control flow.zData-dependent branchingzattempted to jump with zyDetected data-dependent branching (e.g. `if my_tensor.sum() > 0:`). Dynamo does not support tracing dynamic control flow.gb_typecontext explanationhints)rr>rrrrmrndimdtyper|rint32int64rrrr FUNDAMENTALr9)ry trace_inforexamplerrrraise_jump_graph_breaks<      z,generic_jump..raise_jump_graph_breakrrrrr+ extra_msgrrc sT|sJd}z|Wnttfy$}z|}WYd}~nd}~ww|dus+J|r6||j||j|jt||d| |t d|j j |tdt|||gdd}|||j|}rs| ||jduszJ||j|}tjdkr|j tdgt|j|dd } | ||j | g||dS) Nrrzgeneric_jump triggered compilez generic_jump rr stack_pops TO_BOOLr)r)should_compile_partial_graphr:r;maybe_has_backedgeraise_loop_graph_breakf_codelog_graph_break code_optionsrr.rrrcompile_subgraphr?r_ frame_summarypopcreate_call_resume_atnext_instructionrrB version_infoadd_output_instructionsr&rcopy_positions) rrryrreall_stack_locals_metadataif_nextif_jump jump_inst)r.rrrjump_graph_breaksT        z&generic_jump..jump_graph_breakc s|}tjrtjjdkrt|r|}|rFt| r&| |S| r2|||dSt dd|dgt jdddd|rb|jjd tjgt||fiR| |dSt|tr|j}t|tjst|dk}tjjj|}|st d t|d gt jd| |dS|jjd tjgt|fiR}t ||t!|j"|d }|jjd tjgt||fiR| |dS|rt|t#r|j$rt%|j$&t'j(| rr|)|| |dSdS|r| r|||dSt|t*r%|j+|j,}|r#r|)|| |dSdSt|t-rz|.|d } Wn+t/j0y^t/1|z|.|d} Wnt/j0y[t/1|d} YnwYnwt| t2t3fr| 4|gi}t5t5| dddd} |r| } | d krt| tst/j6t7|dt8| j9gdt| tt:fr| rr|)|| |dSdSdSt|tr|;rՈr|)|| |dSdSt dd| d|dgddSdrr|)|| |dSdS|s#|<|r#t=|>|r!r|)|| |dSdSt|tr}zt|jtjr9|;|j} nt?|jdk} Wn%t/j@yf} z| ra|||d| dWYd} ~ Sd} ~ ww| r{rt|)|| |dSdSt|tAjBrdrr|)|| |dSdSddl$mC}|j$dur||j$rĈ|Drˆr|)|| |dSdS|dS)Nrz>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).rrz#Assertion failed on symbolic shapesr)r__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)Err rewrite_assert_with_torch_assertrBflagsoptimizerhis_python_constantras_python_constantjumprr9rr is_tensorr create_proxyr| _assert_asyncr^r>rsym_numSymBoolr} experimentalsymbolic_shapes expect_truer USER_ERROR scalar_tensorrdrXrrmrr> make_guardr=SEQUENCE_LENGTHr.r get_submodule module_keyr var_getattrrObservedAttributeErrorhandle_observed_exceptionrrtrroraise_observed_exception TypeErrortyperr evaluate_exprhas_unpack_var_sequencerunpack_var_sequencerr;rBackwardHookVariablerget_real_value)rrryrgsym_exprresultscalar_to_tensor_proxyscalar_to_tensorr;rF method_name result_value eval_resultrrrr.rr[rrinnersR                                 "       zgeneric_jump..inner)ryrarr)r) rrrr+ryrarrrrrrrr+rrr)r[r.rrrr generic_jumps '9?rcgr0cleanuplist[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_stackr>rr extend_outputr try_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_fnr rrcs0td fdd }dfd d |S)Nrrrr+rrc st|j}|_|}||r|jdusJ|||jSzz ||WW||_Sttfy}zr|jrV|js;|jr<t |trE| t dd|jddgt j |dt|ddr]|sb|rm||j||j|jdt||d t |tr| |d tt|d t|t|d |g|_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_exc skip_frameFz: r graph_breakrG real_stack)current_instruction_push speculaterrr:r;active_generic_context_managers one_graphrr>remove_from_statsr9rCAUSED_BY_EARLIER_GRAPH_BREAKrorrrrrrr add_to_statsr?rr)rr prev_push speculationexcp)handle_graph_breakrrr.rrwrappers`  -      '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)Nr r CALLPRECALLz%s triggered compilerrrrKW_NAMESraFrl) rBrrrT stack_effectopmapargopcoderrrrrr0root_txrrrUkw_namesrrr&r"rrcopy exn_tab_entryr/r.rrr) rrrrrrrr call_insts inst_copyr.rrr)s\              zIbreak_graph_if_unsupported..decorator..handle_graph_breakr)rrrr+rr?rr)r8r9)rrrr.)rrr decorators9>z-break_graph_if_unsupported..decorator)rr rrr)r.rr%rr$rbreak_graph_if_unsupporteds}r&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_missingrs    z4BytecodeDispatchTableMeta.__init__.._missingc s&i|]\}}|t|t|qSr)ror8partial)rrr)r,rrrr~sz6BytecodeDispatchTableMeta.__init__..csg|]}|qSr)rnrrR)dispatch_tablerrrNsz6BytecodeDispatchTableMeta.__init__..)rrrrrr)super__init__rTrrranger/)rrr(r) __class__)r,rr/rr2os   z"BytecodeDispatchTableMeta.__init__) rrrrr(rr)rrr)rrrrr2 __classcell__rrr4rr'lsr'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)defaultzExceptionVals | None_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_idxrcCs\|j}r t|tur |St|j|dkr,|j|}|||d||ur,|||SNrr) __context__rrgrr8_set_context_recursive set_context)rr=rCctxprevrrrrFs  z%ExceptionStack._set_context_recursivecCsb|}}d} |j}t|turdS||ur |tddS|}||ur(dS|r-|j}| }qr)rErrgrGcreate)rr=oslow_oslow_update_togglerrrr_break_context_reference_cycles  z-ExceptionStack._break_context_reference_cyclecCs$||t|jd||dSNr)rFrr8rNr?rrrr>sz=ExceptionStack._set_context_and_break_context_reference_cyclecC |jSr)r8rrrrrrrzExceptionStack.popcCrr)r8rr?rrrrrIzExceptionStack.appendcCs t|jSr)rr8rrrrrrzExceptionStack.__len__rcCs |j|Sr)r8)rrrrr __getitem__rzExceptionStack.__getitem__rcCsd|jd|jS)Nzself._exc_stack=z - self._current_exception=)r8r:rrrr__str__zExceptionStack.__str__r)r=rrr)rr)r=rrCrrr)rr)rrrrr)rrrrrrrr8rr:r<r@rArBrFrNr>rrrrQrR__repr__rrrrr7s"            r7cs 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<dd6d7Zdd8d9Zdd;d<Zdd=d>Zdd?d@ZddAdBZ ddGdHZ ddKdLZ ddNdOZ dddRdSZ ddTdUZddVdWZddXdYZejdZkrՐdd\d]Zndd^d]Zedd_d`ZddbdcZd dddeZddfdgZd didjZd dldmZd dndoZd dqdrZddsdtZddudvZddwdxZddydzZ dd}d~Z!dddZ"eZ#dddZ$dddZ%dddZ&e'j(d ddZ)dddZ*dddZ+e,dddZ-dddZ.dddZ/dddZ0e0Z1dddZ2e,dddZ3dddZ4dddZ5e5Z6e5Z7e8e9j:dZ;e8e9je8e9jd?Zdd@dAZddBdCZddDdEZddFdGZddHdIZddJdKZd!dNdOZd"dRdSZddTdUZddVdWZddXdYZddZd[Zdd\d]Zdd^d_Zdd`daZddbdcZeZddddeZddfdgZddhdiZddjdkZddldmZddndoZddpdqZddrdsZee9jZee9jZee9j:Zee9jZee9jZee9jZee9jZee9jZee9jZee9jZee9jZee9jZee9jZeVddtd؍ee9jZee9jZee9jZee9jZee9jZee9jZee9jZee9jƒZee9jăZee9jƃZee9jȃZee9jʃZee9jʃZee9j̓Zee9jσZee9jуZee9jӃZee9jՃZee9j׃Zee9jكZڐddudvZejdZkrddwdxZܐddydzZݐdd{d|Zސdd}d~Zߐd#d$ddZeVddd؍dddZdddZdddZe5Ze5Ze8e9j.csi|] \}}|vr||qSrrr)readsrrrMs)rVrrZrr`r^rrr}rrprune_dead_localsDs   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)r>rarrFrrrrZs  z:InstructionTranslatorBase.call_function..ryr*z$Attempt to trace forbidden callable )r>rarrall itertoolschainvaluesrryr*callablerUAssertionErrorr.r)rr*rrrrrrrQs   z'InstructionTranslatorBase.call_functionrnSequence[VariableTracker]cCs t|ts t|}||||S)zD Redirect the call to the generator "call_function" )r>rorrr*rrrrrinline_generator_functiongs 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_returnts z5InstructionTranslatorBase.inline_user_function_returnNrcCst|dur|j}|jdkrd|jdnd}t|jj|}|dur"dnd|d}|jjd|d|jj||S)Nrz (inline depth: rrrrz in )rrar<r co_filenameco_name)rrinline_depth_strfuncname funcname_strrrrget_line_of_code_headers$z1InstructionTranslatorBase.get_line_of_code_headercCs8d|d}t|jj|j}|d|7}|S)NzTRACE starts_line rr)r linecachegetlinerrrrstrip)rlog_strrtrrrget_log_starts_line_log_strsz5InstructionTranslatorBase.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)rrrrr starts_lines z%InstructionTranslatorBase.starts_linec CsXt|_|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$t%fy"}z[|j&s|js|j'st(|d drt)|t%rt*d d d d dgt+j,d|j durt-dt)|t%rt*dd dd dgt+j,ddd|_.dt/|}|j0|j1||dWYd}~nd}~ww|j 2|jdS)zzTRACE  Trz3cannot 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.)rrrrrzEncountered 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)3rVrrr`r^rr\ris_non_empty_graphrrcrstep_graph_breakis_trace_bytecode_log_enabledtrace_bytecode_logrrrarrverbose ValueErrorrmrupdate_block_stackr/rrrrrr exception_handlerr(r)r:r;r8ris_tracing_resume_prologueror>r9r DYNAMO_BUGrrrrrr)ripr stack_reprrrrrrsteps                 9zInstructionTranslatorBase.steprrcCs|j}|r+t|jdkr%|j|jdjur'|j|jdjur)|jdSdSdSdS|jrC|jdvrEt|jdksr:r;r-rrrrrRestartAnalysis side_effectslog_side_effects_summaryrrGr|r} GraphModule nn_modulesgraphprint_readablepartial_fx_graphre get_record exec_recordpop_txrmark_bytecode_tracing_stop)rrrreadable_graphrrrruns                    $zInstructionTranslatorBase.runr=cCs,t|tsJdt||j|dS)Nz"push expects VariableTracker, got )r>rar_r\rr?rrrr.]s  zInstructionTranslatorBase.pushvalscCs|D]}||qdSrr#)rrr=rrr push_manycs z#InstructionTranslatorBase.push_manycCrPr)r\rrrrrrgrzInstructionTranslatorBase.popricsgtfddt|DS)Ncsg|]}qSrr)rrrrrrNkz2InstructionTranslatorBase.popn..)rr3)rrirrrr/jszInstructionTranslatorBase.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) Nr=implicitz5Attempted 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)raref_locals add_local_varr.rVunwrapKeyErrorrQreplacer9rrr)rrrnew_namerrr LOAD_FASTms@         z#InstructionTranslatorBase.LOAD_FASTcCsl|j|vs J|j|j}|jj|}|||jr2|j|jvr4|j |j|j|jdSdSdSr) rar{rVrr load_cellr.rerr)rrcell contents_varrrr LOAD_DEREFs  z$InstructionTranslatorBase.LOAD_DEREFcCsP|j}|}||||j|<|tkr&|}t|tus!J||_dSdSr) rar set_name_hintrVrJrrrr)rrr loaded_vtr=rrr STORE_FASTs   z$InstructionTranslatorBase.STORE_FASTcCs0|j|j}t|tr|||j|j=dSr)rVrnrar>r_maybe_emit_sync_dealloc)rrvarrrr DELETE_FASTs  z%InstructionTranslatorBase.DELETE_FASTrrc Cs ddlm}m}|j}|dus|jdvrdS|jj}|jdidd}t |j }|s0dSd}|j j jD]} | |vr?| }q7|dusI|jdkrKdS|jdidd} || kr\dS|durd||}| durl||} |} |j dtjjj| | fi|j dtjjj| ||fidS)Nr)get_current_stream new_event)cudaxpucustomstreamrr)variables.streamsrrdevicerrrrmrnr userskeysrrnodesrrr|opsstreams record_event sync_deallocas_proxy) rrrrrr alloc_streamr last_userrilast_use_stream event_idxrrrrsH z2InstructionTranslatorBase._maybe_emit_sync_dealloccCsb|j|vs J|j|j}|}|jj||t|ts"J|j dur/| |j dSdSr) rar{rVrrr store_cellr>r} local_namer)rrrr=rrr STORE_DEREFs  z%InstructionTranslatorBase.STORE_DEREFcCsX|j}|durtj|jdS|j|}|s$tj|jd|j|<|j|}|dus*J|S)Nry)rrgrJra_constants_cache)rrrRr=rrr _load_consts   z%InstructionTranslatorBase._load_constcCs|||dSr)r.rr0rrrr]rSz$InstructionTranslatorBase.LOAD_CONSTcCs|j}|jr&||jvr|j||j|n||jvsJ|j||jj|<||jvr0||S||jvrK|jj |j|}| |jj ||dS|j|}| t ||t|dSr)rare f_globalsadd_global_var f_builtinsbuiltins load_builtinrWrrr. load_globalrarbrN)rrrvariableryrrr _load_globals     z&InstructionTranslatorBase._load_globalcCs$d}||}t|}t|||S)Nztorch.nn.modules.module) import_sourcerrarb)r module_name module_sourcefglobals_valuerrrnn_modules_globals_vts z/InstructionTranslatorBase.nn_modules_globals_vtcCsj|jdusJtjdkrtjdkr|jdr||||tjdkr1|jdr3||dSdSdS)Nrrr)rrBr PUSH_NULLrr0rrr LOAD_GLOBAL s  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) rrarNrWr<rrtrack_global_existingr>rr9 store_global)rrryrrrrrr STORE_GLOBALs     z&InstructionTranslatorBase.STORE_GLOBALrrNcCsd|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>rr?r@rGr.rr_) rrr5rCr recorded_nameryrpkgtop_level_module_namerrr IMPORT_NAMEfsR        z%InstructionTranslatorBase.IMPORT_NAMEcCs||||jdSr)DUP_TOP _load_attrrar0rrr IMPORT_FROM z%InstructionTranslatorBase.IMPORT_FROMracCsv||jvrtddd|dgtjd|j|}t|r/t|jj}t||}t |||St |s5Jt ||S)Nz%failed to find name in frame builtinsrzFailed to find name `z` in frame's builtins.r) rr9rrrrNr%name_of_builtins_dict_key_in_fglobalsrMrarbrT)rrar=builtins_source var_sourcerrrload_builtin_from_argvals$      z2InstructionTranslatorBase.load_builtin_from_argvalcCs|||jdSr)r.rUrar0rrrrsz&InstructionTranslatorBase.load_builtinInstruction | BlockStackEntrycCsZ|jdusJ|jdusJ|jdusJtd|j|j|j|j|_|j|_dS)Nir_count)rrgrrZ incrementindexofr0rrrrs  zInstructionTranslatorBase.jumpFTcC.|jdusJ|jt||jt|jdSrrrrrrr\r0rrr SETUP_LOOP z$InstructionTranslatorBase.SETUP_LOOPcCrZrr[r0rrr SETUP_EXCEPTr]z&InstructionTranslatorBase.SETUP_EXCEPTcCrr)rrr0rrr POP_BLOCKz#InstructionTranslatorBase.POP_BLOCKcC||dSrsetup_or_before_withr0rrr SETUP_WITHr`z$InstructionTranslatorBase.SETUP_WITHcCrZrr[r0rrr SETUP_FINALLYs z'InstructionTranslatorBase.SETUP_FINALLYc Cs|}||z ||}||WdSttjfyP}z)t|tjr.t|t j dkr<|t dn|| |WYd}~dSd}~wwNr)rrealizer. next_variable StopIterationrObservedUserStopIterationr>rrBrrgrJr)rritr=rrrrFOR_ITERs      z"InstructionTranslatorBase.FOR_ITERcCs"t|tjtfr||gi}|Sr)r>rrerrr?rrr_create_exception_type s  z0InstructionTranslatorBase._create_exception_typerrcCsR|}||d}t|ttfsJt||}||dt|d|gidS)Nr __setattr__) rrr>rgrfrom_frame_summary call_methodrarb)rrrtbnew_tbrrr_attach_traceback_to_exception s z8InstructionTranslatorBase._attach_traceback_to_exceptionrcCs||}t|jr t|tjr |jtur t |t  |gi}| |r4t |dddur4tjj|_| |rV|j|t|j}t |dd}|d||dtjt|d|gddS)N python_stackraised exception )rz/exceptions must derive from BaseException, not r)rmr,rr>rr~exc_typerirarbrr_isinstance_exceptionror|_guardsr extract_stackrtrdr@rget_dynamo_observed_exception debug_reprrrpython_type_name)rr=observed_exception_typertrrr_raise_exception_variable s0         z3InstructionTranslatorBase._raise_exception_variablecCsF|jdkr/t|jstjt|dgdt|jsJ|jd}||s(J|||dS|jdkrW|jd}z||W|j }| |dS|j }| |w| }| }z%||W|j }| || |}| |dt|d|gidS|j }| || |}| |dt|d|giw)NrzNo active exception to reraiserrlrrn __cause__)rrrdrrrrwr~r\rBrsrrmrprarb)rrr=curr_excfrom_vtcauserrrrSN sN              z'InstructionTranslatorBase.RAISE_VARARGScCsD|jd}t|ts J|jturtdddgddS||dS)Nrlz CLEANUP_THROW with StopIterationrzRReceived StopIteration when handling generator.throw/close. This is not supported.r)r\r>r~rvrir9RERAISErrtosrrr CLEANUP_THROWv s   z'InstructionTranslatorBase.CLEANUP_THROWcCsltjdkr#|}|jr|}||dS||||dS|}|}|}||dS)Nr)rBrrrar~r.)rrr=r_exc_tbrrrr s  z!InstructionTranslatorBase.RERAISETypeIs[ExceptionVals]cCs t|tSr)r>rr?rrrrw rz/InstructionTranslatorBase._isinstance_exceptioncCsg}tjdkrLtjdkrdnd}t|j|ksJ|j| }|jd}||s+Jt|j}||d}tjdkrKt|jdt sK| |jdn%t|jdksUJ|jd }|jd }||sfJt|j}||d}||||g7}| ||idS) Nrrrlrir) rBrrr\rwrervrr>rrr)rrrfn_locr*r=typrqrrrWITH_EXCEPT_START s0         z+InstructionTranslatorBase.WITH_EXCEPT_STARTraised_exceptionr c sddfdd }tjdkrajj}|rGtj|jkr*tj|jks|jr8 t jj  j |dSjj }|ttur_|tjr6j}|jjdkrdj tjd krjtturtd td gtjd j}|jjdksrj }j tj|jkrɈtj|jksttd ddd }j t!|dtjtj dkrj d} t"# | t"$|j%n t&'d t&'d t&'d t"# | t"$|j%|dSjtturE|)NzDynamo found no exception handler at the top-level compiled function when encountering an exception. Exception will propagate outside the compiled region.rrcsRj}t|}t|sJtdd|gtj tj ddS)NzObserved exceptionrur) rdrBrrz python_typer>r9r{rrr+)r dynamo_excobserved_exn_gb_explanationrrrrbubble_exception_to_interpreter s   zTInstructionTranslatorBase.exception_handler..bubble_exception_to_interpreterrEXCEPT_HANDLERrrz#Observed exception (EXCEPT_HANDLER)z This graph break is unexpected.rg.Arrr)(rBrr^r rr\depthrlastir.rarbrqrdrBrrrsrr-rrrr/r9rrrrArr+rrrrrrervrgrJ) rrrr rblock_stack_entry exception_varexcept_handler_inst old_exceptionrrrr s                   z+InstructionTranslatorBase.exception_handlercCsN|}t|jdkrtd}n|jd}|||||jdS)Nrrl)rrrdrgrJr.rA)rrr=prev_excrrr PUSH_EXC_INFOG s    z'InstructionTranslatorBase.PUSH_EXC_INFOcCstjdkr|}t|jsJ|jdSt|jdks J|jdjjdkr-td|j| dt|js>J|jdS)NrrrlrzYBug in Dynamo tracing of exception handling.Top of the block stack is not EXCEPT_HANDLER.r) rBrrrrdrrrrr/)rrrrrr POP_EXCEPTd 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)Nrrrlz Exception with bad expected typez"`except ...` has unsupported type r=rzCaught 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\rrBrr>rer|rrr9rrrrwr issubclassrvr*r)rexpected_exc_types exc_instanceexpected_types expected_typerrrcheck_if_exc_matchesy sr           z.InstructionTranslatorBase.check_if_exc_matchescCs|t||dSr)r.rarbrr0rrrCHECK_EXC_MATCH sz)InstructionTranslatorBase.CHECK_EXC_MATCHcCs|s ||dSdSr)rrr0rrrJUMP_IF_NOT_EXC_MATCH sz/InstructionTranslatorBase.JUMP_IF_NOT_EXC_MATCHcCs:|jdkr ||dS|t|j||didS)Nzexception matchr)rarr.rr/r0rrr COMPARE_OP s "z$InstructionTranslatorBase.COMPARE_OPcCs |t|t|gidSr)rrarbiterrr0rrrGET_ITER s 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}|}|||idSr)r/rarr)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)Nrrrz%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)rarmrrBrr>rr9rrrwhas_force_unpack_var_sequencer|force_unpack_var_sequencerrfcall_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/rar>r|rrrrzipr)rrargnamesrr* kwargs_listrrrrCALL_FUNCTION_KW% s &z*InstructionTranslatorBase.CALL_FUNCTION_KWcCs\|tj|dd|jd}|jd|}tjdkr"||dS|tj||ddS)Nrrrco_namesr) rrrrarrBrrO LOAD_METHODrrrrarrrLOAD_METHOD_SUPER5 s   z+InstructionTranslatorBase.LOAD_METHOD_SUPERcCs:|tj|dd|jd}|jd|}||dS)Nrrrr)rrrrarrOrrrrLOAD_ATTR_SUPER> s z)InstructionTranslatorBase.LOAD_ATTR_SUPERcCs`||j|}tjdkr||||dStjdkr,||||dStd)NrrzPLOAD_METHOD should have been rewritten to LOAD_ATTR. We should never reach here.)rOrarrBrr.r#rrrobjrrrrD s     z%InstructionTranslatorBase.LOAD_METHODcCstd)Nz^CALL_METHOD should have been rewritten to CALL_FUNCTION. This function should never be called.)rr0rrr CALL_METHODU sz%InstructionTranslatorBase.CALL_METHODattrcCs8|}t|t||t||gi}||dSr)rrarbrorr.)rrrrrrrrOZ s z$InstructionTranslatorBase._load_attrcCs2tjdkr|jdr||dS||jdS)Nrr)rBrrrrOrar0rrr LOAD_ATTRc s   z#InstructionTranslatorBase.LOAD_ATTRzkEncountered graph break when attempting to trace STORE_ATTR: storing an object's attribute, e.g. x.attr = ycCs8|d\}}t|t||t||j|gidS)Nr)r/rarbsetattrrra)rrr=rrrr STORE_ATTRk s  z$InstructionTranslatorBase.STORE_ATTRcCs>|}|||jt|t||t||jgidSr)r_maybe_sync_dealloc_attrrararbdelattrrrrrr DELETE_ATTRw s z%InstructionTranslatorBase.DELETE_ATTRrcCs@|jj||r|jj||}t|tr||dSdSdSr)rrhas_pending_mutation_of_attr load_attrr>rr)rrrattr_varrrrr s  z2InstructionTranslatorBase._maybe_sync_dealloc_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. rrrorprr)rr)rr&ra)rrrW return_instrrrcodegen_return_with_pops s   z2InstructionTranslatorBase.codegen_return_with_popsr resume_instrmrA resume_codeslist[types.CodeType]rr0is_leafhandle_inactive_ctxtuple[types.CodeType, str]csb|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-.| |j/j0d urj01|j/d| t2d|j3d7<|| 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|rrr~rrr sz:InstructionTranslatorBase.create_resume..c3s|] }|vr|VqdSrrrargnames_null_setrrr c3s|] }|vr|VqdSrrrrrrr rrrrNTrrz&variables should not be NULL in < 3.12css|]}|jjVqdSr)rrqrrrrrr? rcs|]}|VqdSr)r rrrrrC rorig_graphmodulecSrrrrrrrrO z9InstructionTranslatorBase.create_resume..rresumesr)4rstack_ctx_argsstack_ctx_idxes_origrrhr\ append_outputr%rrr)rrr&locals_ctx_argsrVrrr-rr.rqrr`rr locals_null_keysrr!rrBrstack_null_idxesr^rIlookuprrrrr/ get_contextrnweakrefrefrinstall_resume_function_globalrrladd_resume_functionrWr)rrrrmrrrrjrj_origrHr resume_name all_argnamesr argnames_nullr stack_lennew_codeorig_graphmodule_mayber)rr}rrr 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. NrrorrrrrT)rr0rrrrrrrr\rrr)r3rr&rUrr.rr$rrr!rr%rdeepcopyrVrr)rrrrtxesidxes resume_instsrrrcurrent_num_stackrstack_insert_idx filter_instsr resume_namesrR resume_coderrrrrc s                 z/InstructionTranslatorBase.create_call_resume_atrcCs|tdtt||D]H\}\}}|t|dkrn9|jrE|t|||g||j |ddgt dt dddn || |dd|t dq|t dt d t|dd g|t d |d jr||d |g||j |d ddgt dt ddd|gtd n|t dg| |d dtd |tt|d |gt d|d t d |gtd t d dd t dt ddd |tdddS)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 rrT)r) push_nullFrrrrrrlr LIST_EXTENDN)rr$rVrrrxr%rrcreate_load_globalr)r"load_function_namer&r(r#)rrrrRrrvrrrr s         z-InstructionTranslatorBase.codegen_call_resumecCsztjdkr|jj}|r|jr|j|jdjurdStdd|jDo<|j o<|jp-|j o<|j o<|j o<|j j jduS)NrrlFcsrr)rrrrrr rzIInstructionTranslatorBase.should_compile_partial_graph..)rBrr^r rrrrrirrrrcurrent_tracerr)rrrrrr 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)Nr __setitem__)r/rp)rrr=rkeyrrrr sz&InstructionTranslatorBase.STORE_SUBSCRcCs0|d\}}|||||d|gidS)Nr __delitem__)r/_maybe_sync_dealloc_subscrrp)rrrrrrrr s z'InstructionTranslatorBase.DELETE_SUBSCRrcCs|ddlm}ddlm}d}zt||r|||}n t||r%||}Wn ty/Ynwt|tr<| |dSdS)Nrrl)rw) variables.dictsrmvariables.listsrwr> getitem_constmaybe_getitem_constrrr)rrrrmrwitem_varrrrr s$       z4InstructionTranslatorBase._maybe_sync_dealloc_subscrcCs||j}|t|dSr)r/rar.r|rrrrrr BUILD_TUPLE s z%InstructionTranslatorBase.BUILD_TUPLEcCs"||j}|t||ddS)N)r)r/rar.r{r rrr BUILD_SLICE 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_nested sz=InstructionTranslatorBase._can_speculate_comprehension_nestedcCs0t||rdS||j}|t||dSr)r1r/rar.rarbr rrrr s  z$InstructionTranslatorBase.BUILD_LISTcCs>tjr tdddgd||j}t|td}||dS)Nzmissing BUILD_SET handlerrz:Missing BUILD_SET bytecode handler (for testing purposes).r mutation_type)r+inject_BUILD_SET_unimplemented_TESTING_ONLYr9r/rarr`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/rarrNotImplementedErrorr9rrrr.r`)rrrseqsrseqrrrBUILD_LIST_UNPACK s   z+InstructionTranslatorBase.BUILD_LIST_UNPACKcCs|j|tddS)Nr)rr|r0rrrBUILD_TUPLE_UNPACK sz,InstructionTranslatorBase.BUILD_TUPLE_UNPACKcCsVt||rdS||jd}tt|ddd|ddd}|t||dS)Nrr)r1r/rarrr.rarb)rrrdrrr BUILD_MAP s "z#InstructionTranslatorBase.BUILD_MAPcs\|j}fdd|D}i}|D]}t|tsJ||jqt|dS)Ncs$g|]}tt|giqSr)rarbrrrrrrrN sz>InstructionTranslatorBase.BUILD_MAP_UNPACK..) r/rar>rmupdaterr.rarb)rrrrrFrrrBUILD_MAP_UNPACKs  z*InstructionTranslatorBase.BUILD_MAP_UNPACKc Csl|}||j}t|tsJ|sJ||}t|t|ks&J|t |t t ||dSr) rr/rar>r|rrrr.rarbrr)rrrrrrrBUILD_CONST_KEY_MAPs    z-InstructionTranslatorBase.BUILD_CONST_KEY_MAPcCsb|d\}}|jdksJ|jdusJ|j|j }t|ts%J||d||fidS)Nrrr)r/rarr\rgr>rmrp)rrrrrrrrMAP_ADD*s z!InstructionTranslatorBase.MAP_ADDcCb|}|jdks J|jdusJ|j|j }t|ts J|s&J||d|gidS)Nrrrrarr\r>r is_mutablerprrrrrrrSET_ADD2 z!InstructionTranslatorBase.SET_ADDcCr Nrrr!r#rrr SET_UPDATE;r%z$InstructionTranslatorBase.SET_UPDATEcCsn|}|jdks J|jdusJ|j|j }t|ts"J|s(J|jj ||j |dSr) rrarr\rgr>rzr"rrmutationrrr#rrrrDs z%InstructionTranslatorBase.LIST_APPENDc Cs(|j}tjdkr |}|}tjdkr%t|jdsJt||jj}d}d}d}d}tjdkrV|durV|d@r>|}|d@rF|}|d@rN|}|d@rV|}t |||j |||} |rt |t siJ|j } ttt| ddd| ddddd td } | |d | || dS) Nr co_qualnamerrrrTstrictrr)rrBrrrryrarbr)rqrr>r|rrmrrr` get_dict_vtsetitemr.) rrrfn_namervdefaultsclosurer kwdefaultsr*rannrrr MAKE_FUNCTIONNsP   $ 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.)rrrr3rar>rrror rrrr9rrrrrrr.)rrrr=rRrr5rrs0    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) rarrrrrrr.r|r9rrr) rrprefixsuffixrr vals_prefix vals_list vals_suffixitemrrr UNPACK_EXs,         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)rhr9r0rrrgraph_break_on_leaf_functions z6InstructionTranslatorBase.graph_break_on_leaf_functioncCs|jdkr ||dSdS)NGRAPH_BREAK_IF_LEAF)rar>r0rrrrs zInstructionTranslatorBase.NOPcC |dSrrr0rrrrrJz!InstructionTranslatorBase.POP_TOPcCs(|}|}||||dSrrr.rrr{rrrrROT_TWOs z!InstructionTranslatorBase.ROT_TWOcCs:|}|}|}||||||dSrrA)rrr{rcrrr ROT_THREEs   z#InstructionTranslatorBase.ROT_THREEcCsL|}|}|}|}||||||||dSrrA)rrr{rrDrrrrROT_FOURs   z"InstructionTranslatorBase.ROT_FOURcCs |}||||dSrrA)rrr{rrrrNs z!InstructionTranslatorBase.DUP_TOPcCs<|}|}||||||||dSrrArBrrr DUP_TOP_TWOs    z%InstructionTranslatorBase.DUP_TOP_TWOryflagcCsd|dkrt|t||giS|dkr t|t||giS|dkr0t|t||giS|S)Nrrr)rarbrrrascii)rryrHrrr_convert_valuesz(InstructionTranslatorBase._convert_valuefmt_specrcCs|}t|tr#ddlm}m}|j||||jd}||dS| ||d@}t |d| d}| ttj||gidS)Nr)LazySymNodeFormatStringrvrErz{:})rr>rtorch._dynamo.variables.lazyrLrvrJrr.rJrarbrrrerformat)rrKrryrLrvfmt_varrrr _format_values   z'InstructionTranslatorBase._format_valuecCs@|j}|dus J|d@dkr|}nt|d}|||S)Nrr)rrrarbrQ)rrrrKrrr 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/rrr>rStringFormatVariable format_stringrsym_argsr r sym_kwargsr9rrrrr.rJr)rrformat_string_partsrrpartrrr BUILD_STRINGs<      z&InstructionTranslatorBase.BUILD_STRINGcCsF|jdks |jdks J|jdkrd}nd}td|d}||dS)Nrriszis notrr)rar&r)rr new_argvalnew_instrrrIS_OP9s   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__)rar/r.rprObservedTypeErrorr:r>rr rrarbrB UNARY_NOT)rrleftrightrrrrr CONTAINS_OPBs2  z%InstructionTranslatorBase.CONTAINS_OPcCr )Nrr)rrarr\r>rzr"rpr#rrrr_r%z%InstructionTranslatorBase.LIST_EXTENDcCs&|t|t||gidSr)r.rarbrrrr0rrr LIST_TO_TUPLEhsz'InstructionTranslatorBase.LIST_TO_TUPLEcCs|jd}||s J|jtur>t|t|t|dgi}||t|d|||t|d|||jd<dSdS)Nrlzgenerator raised StopIterationrEr) r\rwrvrirarbrr call_setattr)rrr=new_valrrrSTOPITERATION_ERRORms    z-InstructionTranslatorBase.STOPITERATION_ERRORcCsf|}|jdks J|jdusJ|j|j }t|ts"J|s(J||d|gidSr&) rrarr\rgr>rmr"rpr#rrr DICT_MERGEs z$InstructionTranslatorBase.DICT_MERGEcCr@rrr0rrr GEN_STARTrJz#InstructionTranslatorBase.GEN_STARTcCsJ|jd}|r|t|t|dS|||dgidS)Nrlr)r\rr.rarbrrrprrrrGET_LENs z!InstructionTranslatorBase.GET_LENcCs,|jd}||t|t|gidS)zr If STACK[-1] is an instance of collections.abc.Mapping, push True. Otherwise, push False rlN)r\r.rrarbrCrrrr MATCH_MAPPINGs  z'InstructionTranslatorBase.MATCH_MAPPINGcCs,|jd}||t|t|gidSNrl)r\r.rrarbrFrrrrMATCH_SEQUENCEs  z(InstructionTranslatorBase.MATCH_SEQUENCEc Csx|d\}}}t||j}||t|t||||gitjdkr:|j d}|t|t |t  dSdS)Nrrrl) r/rarbrr.rrDrBrr\r\rg)rrsubjectrnamesrrrrr MATCH_CLASSs    z%InstructionTranslatorBase.MATCH_CLASScCsx|jd}|jd}t|tsJ||t|t||gitj dkr:|jd}|t|t |t  dSdS)Nrlrr) r\r>r|r.rrarbrErBrr\rg)rrrrrrrr MATCH_KEYSs    z$InstructionTranslatorBase.MATCH_KEYScC||ddS)Nrr.rUr0rrrLOAD_ASSERTION_ERRORrSz.InstructionTranslatorBase.LOAD_ASSERTION_ERRORcCrr)N__build_class__rsr0rrrLOAD_BUILD_CLASSrSz*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_instr_r0rrrRESUMEs   z InstructionTranslatorBase.RESUMEcCs|jdusJt|j||Sr)r_binary_op_lookupr0rrr BINARY_OPsz#InstructionTranslatorBase.BINARY_OPcCrrrr0rrrr rz!InstructionTranslatorBase.PRECALLcCsV|jd|j}t|tsJ|D] }t|tsJq|jdus"Jtj|d|_dS)N co_constsr)rrr>rrrrgrJ)rrrrrrrr s z"InstructionTranslatorBase.KW_NAMEScCs|tdSr)r.rr0rrrr#rIz#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)rBrrr>r|rrrryrr/rrrrr) rrr|rcontentsr*rrrrrr_calls4   zInstructionTranslatorBase._callzTEncountered graph break when attempting to trace CALL: a function call, e.g. f(x, y)cCrarr~r0rrrrFszInstructionTranslatorBase.CALLcCs&|jdusJ||j|j dSr)rr.r\r0rrrCOPYMszInstructionTranslatorBase.COPYcCs<|jdusJ|j|j |jd|jd<|j|j <dSrl)rr\r0rrrSWAPQs.zInstructionTranslatorBase.SWAPcCrrrr0rrrCACHE]rzInstructionTranslatorBase.CACHEcCrarrbr0rrr BEFORE_WITH`r`z%InstructionTranslatorBase.BEFORE_WITHrH8ContextWrappingVariable | GenericContextWrappingVariablecCst|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)Nrrl)r>risupports_graph_breaksrrrBrr rrrr-rrrrr\enter)rrHrrrrr enter_ctxcs*    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|)rHrrrunsupported_ctx_graph_breaks  z5InstructionTranslatorBase.unsupported_ctx_graph_breakcCsZ|}t|ttfs||t|ttfsJ|t||j||||dSr) rr>rhrirr.rkrr)rrrHrrrrcs z.InstructionTranslatorBase.setup_or_before_withcCs|jsJ|j|dSr)r_r`rr0rrrrwrQz,InstructionTranslatorBase.append_prefix_instcCsLtjdkr|jst|j|jtsJ|jj |j|j<dS| |dSrf) rBrr_r>rVrarrrtrack_cell_newrwr0rrr MAKE_CELLs  z#InstructionTranslatorBase.MAKE_CELLcCrarrwr0rrrCOPY_FREE_VARSr`z(InstructionTranslatorBase.COPY_FREE_VARScCrarrr0rrrRETURN_GENERATORr`z*InstructionTranslatorBase.RETURN_GENERATORcCsbtjdkr |n|dtjdkr-|j|}||jvr/|j||jd8_dSdSdS)Nrrrr)rBrrr/rY_comprehension_end_for_ipsdiscard_comprehension_depth)rr current_iprrrEND_FORs       z!InstructionTranslatorBase.END_FORcCsDt|j|jdtrtd|jd|jgtjd||dS)Nz)LOAD_FAST_CHECK on uninitialized variablez/Attempted to load uninitialized local variable r) r\rVrnrarr9rrrr0rrrLOAD_FAST_CHECKs z)InstructionTranslatorBase.LOAD_FAST_CHECKcCs6|j|jvr |tn||t|j|j<dSr)rarVr.rrr0rrrLOAD_FAST_AND_CLEARs  z-InstructionTranslatorBase.LOAD_FAST_AND_CLEARcCsJ|tj|dd|jdusJ|jd@r||dS||jdS)Nrrr)rrrrrrOrar0rrrLOAD_SUPER_ATTRs  z)InstructionTranslatorBase.LOAD_SUPER_ATTRcCs|jdkr ||dS|jdkr||dS|jdkr+|t||dS|jdkrD|}t t |}||dSt dd|jd|jdgt j d dS) Nrrrz Missing CALL_INTRINSIC_1 handlerzCALL_INTRINSIC_1 operand: z,No handler implemented for CALL_INTRINSIC_1 instruction.r)rargUNARY_POSITIVEr.r|rrrrTypingVariabler r9rr+)rrrtvrrrCALL_INTRINSIC_1s        z*InstructionTranslatorBase.CALL_INTRINSIC_1cCs||}|}|jdkr(t|tsJ||dtd|gi||dStdd|jd|jdgt j ddS) Nrrn__type_params__z Missing CALL_INTRINSIC_2 handlerzCALL_INTRINSIC_2 operand: z,No handler implemented for CALL_INTRINSIC_2 rr) rrar>rnrprgrJr.r9rr+)rrarg2arg1rrrCALL_INTRINSIC_2s"     z*InstructionTranslatorBase.CALL_INTRINSIC_2cCs|}|||dSrrArrrrEND_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)r|rr0rrrCALL_KWsz!InstructionTranslatorBase.CALL_KWcCs|jjdvsJdS)N)POP_JUMP_IF_TRUEPOP_JUMP_IF_FALSEr`)rrr0rrrr$sz!InstructionTranslatorBase.TO_BOOLcCs|j}|dus J|}t|tsJ|}|d@r=tjdks#J||t|dgi}| |dt d|ginG|d@rE||_ n?|d@rut|t sPJ|j}ttt|ddd|dddd d td }||d|n|d@r}||_n|d@r||_||dS) Nrrrnrr*rrTr+r)rrr>rqrBrrrarbrprgrJr1r|rrmrrr`r-r.r2r0r.)rrrr*rrr3rrrSET_FUNCTION_ATTRIBUTE.s>  $ z0InstructionTranslatorBase.SET_FUNCTION_ATTRIBUTEcCs*|jdusJ||||jdSr)rr.rJrr0rrr CONVERT_VALUEVsz'InstructionTranslatorBase.CONVERT_VALUEcCs|t|dddS)Nrr)rQrarbr0rrr FORMAT_SIMPLEZz'InstructionTranslatorBase.FORMAT_SIMPLEcCs||ddSr)rQrr0rrrFORMAT_WITH_SPEC]rSz*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) r>rr_load_special_namesrrhrirr.rjr#rkrO)rrrrHrrrr LOAD_SPECIALos(    z&InstructionTranslatorBase.LOAD_SPECIALcCs|t||jdSr)r.rarbrar0rrrLOAD_SMALL_INTrz(InstructionTranslatorBase.LOAD_SMALL_INT)rrrranycCs0t|jts Jd|||j|jdS)Nz2expected LOAD_COMMON_CONSTANT arg to be set to int)r>rrr.rU_common_constantsr0rrrLOAD_COMMON_CONSTANTsz.InstructionTranslatorBase.LOAD_COMMON_CONSTANTcCs |jdkrdd|_dSdS)NrcSrNTrrrrrrrz>InstructionTranslatorBase.is_non_empty_graph..TF)r count_callsrrrrrrs z,InstructionTranslatorBase.is_non_empty_graphadditional_stack_frameslist[Any] | NonecCs.|durg}dt|gtt|S)Nr)r traceback format_listrrr)rrrrrformat_frame_summarysz.InstructionTranslatorBase.format_frame_summarytraceback.FrameSummarycCs(tjt|jdd|jt|jddddS)Nr rF) lookup_line)r FrameSummaryrorrrrrrrs   z'InstructionTranslatorBase.frame_summarycCs&t|jdd}td}||duS)Nrrz.*torch/nn/modules.*)rorrecompilematch)rrnn_modules_patternrrris_co_filename_from_nn_moduless z8InstructionTranslatorBase.is_co_filename_from_nn_modulesr7cCs,|j|t|}tt|tj|Sr) rinstall_global_by_idrrr>rOrr= WEAKREF_ALIVE)rr7ry global_namerrrstore_global_weakref_by_ids z4InstructionTranslatorBase.store_global_weakref_by_idFakeTensorMode | NonecCs |jjjSr)rtracing_context fake_moderrrrrrz#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)rf)rrpriorrrrstrict_translation_modes z1InstructionTranslatorBase.strict_translation_modercCsF|jdusJ|jdksJ|j|jj|j|jd|j|jdSrD)rrrrrrr`rrrrrsz#InstructionTranslatorBase.speculaterfallback_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) rrrrrrrco_firstlinenorreverser)rrframe_loc_chain_list current_txparent_frame_locrrr_get_frame_loc_chains  z.InstructionTranslatorBase._get_frame_loc_chainrrr)Unsupported | UserError | 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)NrrlrrrrzGraph 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)rencodingrrrrrrCsz;InstructionTranslatorBase.log_graph_break..csdtS)Nr)r format_excruser_stack_tracerrrGrO) 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)(loggedror|rxrryrrrrrrrrr IndexErrorrrr6rrrr4r2r_loggingtrace_structuredr>r:rrgraph_break_log isEnabledForrDEBUGexplainr[rrmr) rrrr user_stackrframe_loc_chainstack_above_dynamo_formattedstack_above_dynamouser_stack_formattedrrrrrs           z)InstructionTranslatorBase.log_graph_breakrvtypes.CodeTypeUnsupported | UserErrorcCs(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 )rvrrrrrks  z0InstructionTranslatorBase.raise_loop_graph_breakr`rrrrexportrrdistributed_stateDistributedState | Noner1tuple[types.CellType] | NonerYdict[Instruction, int] | Nonecst||_||_||_||_||_| |_| |_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) NrrTrlrx)maxlen)rvr1rFr)CO_ASYNC_GENERATOR CO_COROUTINE CO_GENERATORCO_ITERABLE_COROUTINE)Mr1r2rrrrVrWrXrYrZr\rrgr&r^rrrrrr_r`rdrrmrr rr`rrYrrrrrr1rreplay_record_enabledrHrenn_module_stack num_callsrrrrrcrfrhrrirjrlresume_executionrrrrco_flagsr.rerarbrr{rrrrrrrrr lazycacher)rrr`rrrrrVrWrXrYrrrarrdrr1rlrYrrrrr4rrr2ys     z"InstructionTranslatorBase.__init__rr)rr)r*rarr[rrUrr)r*rnrrrrUrra)r*rnrrrrUrrr)rr]rrr)rrrrrr+rr)rr+)rr+rrrr)r=rarr)rr[rrrra)rirrr[)rrrr)rr+rra)rrrrN)rrrlrr5rrr)rarrra)rrVrr)r=rarra)rrrr)r=rarr)r=rarr)rr rr)rrrr)rrarrrr)rr+rrrr)rrrr+rmrArrrr0rrrrrrrr+rrrr)rrrrrr0rr)rrarrarr)rr+rrrr)ryrarHrrra)rKrarrrr)F)rr+r|rrr)rHrrr+rra)rHrarr)rrrr)rr)r7rryrrrrr)rrrr)rr)rrrr]rrrr)rrrr)rrrrrrrr)rvrrrrr)NNN)(rr@r`rrrrrrrrrrVrUrWrUrXrrYrrrrrrarrrrdr7rrr1rrlrkrYrrr(rrrrrnrrwryr{rrrrrrrrrBrrpropertyrrrrr.rrr/rrrrrr LOAD_CLOSURErr]rr8cached_propertyr"r$r(rrr:rBrMEAGER_IMPORT_NAMErPrUrr JUMP_FORWARD JUMP_ABSOLUTErr^not_rr_rJUMP_IF_FALSE_OR_POPJUMP_IF_TRUE_OR_POPr\r^r_rdrerlrmrsr~rSrrrwrrrrrrrrrr&rrrrrrrrOrrrr staticmethodrrrrrrrrr r rrrrzrrBUILD_TUPLE_UNPACK_WITH_CALLrrBUILD_MAP_UNPACK_WITH_CALLrrr$r'rr4rr=r>rrrCrErFrNrGrJrQrRrYr]rcrrdrgrh DICT_UPDATErirjrkrmrprqrtrvr:posrnegUNARY_NEGATIVEr`invert UNARY_INVERTpow BINARY_POWERmulBINARY_MULTIPLYmatmulBINARY_MATRIX_MULTIPLYfloordivBINARY_FLOOR_DIVIDEtruedivBINARY_TRUE_DIVIDEr; 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_ORrxrzrrr#r~rrrrJUMP_BACKWARD_NO_INTERRUPTPOP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUEPOP_JUMP_FORWARD_IF_FALSEPOP_JUMP_BACKWARD_IF_FALSErrrrrcrwrrrrrrrrrrrrrrrrLOAD_FAST_BORROWrPOP_ITERrrrrrrrrrrr contextlibcontextmanagerrrrrrrr2r6rrr4rrsz    #       p .  D  O     #  +      >                 0 (    &    S   <       ;*    1    !                                     /    %    (   n $) metaclasscseZdZed6ddZejd7ddZd8fd"d# Zd9d$d%Z d:d(d)Z d;d*d+Z d9d,d-Z drQrrrNrrr)rrrrrget_example_values    z'InstructionTranslator.get_example_valuecCs6|jD]}t|trt|tjjrdSqdSr) rVrr>rrrr|nnModule)rrrrr$symbolic_locals_contain_module_classs  z:InstructionTranslator.symbolic_locals_contain_module_classcCsLt|jr |jd}r"t|tr$t||td|jd<dSdSdSdS)Nrlr)rr\r>rpryrr`)rrrrr"replace_tos_if_return_is_generators  z8InstructionTranslator.replace_tos_if_return_is_generatorrr+cCs(||jdus J|jdusJtd|j|jtjsE|jdkrE|j sE| sE|j sE|j sE|j sE|jsEtdt|jd|_ttjd|jjd|jdtd|jj|td|gd d |jd krrd ndd }t|d ks~J|djrJ|j| ||dj!t")NrWrzhNo ops traced for the FX graph. `torch.compile` will skip the frame and fall back to eager. Frame info: ztorchdynamo done tracing rrzreturn triggered compile return_valueF)rrorr)#rrrgrZrXrallow_empty_graphsrrrbrrrrrr SkipFramer5rrrrerrrrrr?rrrrrrr(rrrrrr_returnsZ    zInstructionTranslator._returncCrarrr0rrrror`z"InstructionTranslator.RETURN_VALUEcCrarrr0rrrrpr`z"InstructionTranslator.RETURN_CONST)rr-r)$r`rrrrrrrrrr1r\r]rrrr^rrrrrr_rr`rrrrdr7rrrlrkrrr)rrSrrrr)rrrrrrWrXr[r2rfr~rrrrorpr6rrr4rr-s   &    .r-rcCs<g|]\}}ttd|vr|ddnd|ddqS)INPLACErNBINARY_)ror-)rrrrrrrNs$rNrr@rvrget_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_countracaller_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) rrvr caller_infor trace_success stack_entry trace_end_nsrarrtimingrrrprofile_inline_call'sz             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 methodr"symbolic_resultrrrfuncrnrrrrUrracsZd}tj|fdd||||}|WdS1s&wYdS)Ncs jdSrOrarrrrrvs z;InliningInstructionTranslator.inline_call..)rrrbuild_inline_tracer inline_call_)rrrrrtracerrrrrls$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*rqz: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_selfr9rr>rsr5rs get_functionr check_verboseskippedtorch._dynamo.variables.miscrrr*r SkipResultr get_filenameget_namer)rrGrr fn_qualnamerrrrcheck_inlineable{sh             z.InliningInstructionTranslator.check_inlineablecs>t|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-|rt|d} d#} t| t.r2| /s2t0| 1tj2j3r0| 4} nd} | rtt| t5rWj6| j7}t|tj8j9rVt:;|t<=|j>j?d$<nt| t@rt| jA}t|tj8j9rtt:;|t<=|j>j?d$<t|tBr|JtCrtD|jEjFjG|}|St |jEjFjG|}|S)&NFz2failed to bind arguments when attempting to inlinezfunc='z' rz ; args = cSsg|]}|qSr)r)rrrrrrNrzEInliningInstructionTranslator.build_inline_tracer..z ; kwargs = z4Argument mismatch when attempting to trace function r=rz:Encountered unconverted argument when attempting to inlinezfunc: z, arg: zWAn argument to an inlined function was not successfully converted to a VariableTracker.r)rrnrz2Unsupported __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)r positionsrrYrr)headerrtrvcur_instr parent_coderrget_trace_call_log_str s zQInliningInstructionTranslator.build_inline_tracer..get_trace_call_log_strrzINLINING %s%s, %sTrr)Hr>rsrqrorrrrdont_skip_tracingpreviously_inlined_functionsrnrrr bind_argsrr9rrrrrrrrrarrrrr|r _internal log_stateis_artifact_enabledrTBytecoderBrr^rtrace_call_logrr]rrrv is_realizedr peek_typerrrgrrrr}rrrr/rforward__code__rryrrr,&InliningGeneratorInstructionTranslatorrWrXrY)rrrrr tracing_ctxprevious_result sub_localsrrr8rarg0 should_checkmodulerrrrrs    "             z1InliningInstructionTranslator.build_inline_tracerc Cs|j}d|_d|_|j}t}|jr||j}z[z| |Wdn1s,wYWn9t j yM}zd|d|}t |d}~wt tfy^}zd|_d}~wtykt d|wW|j|_d|_n|j|_d|_w|jjrtdS|jdusJ|j|jur|j|j|j|jO_t d||jjj|tjst |t!r|j"rt#|rt |t!r|j$rt |t!sJg}|j%s|jg}t j&t'||ddS|jSt#|rt |t!sJ|j%sJt(|j)t*dS|jS) NFTz!Observed exception DURING INLING z : zFAILED INLINING %szDONE INLINING %srr)+rrhrirrW nullcontextrfrrrr rrr:r;rrrrrrgrJrrrWrrbr traced_coderrrr>ris_generator_from_ctx_managerr,generator_exhaustedis_constant_nonerrirygenerated_itemsr`)rrrv strict_ctxrrGrrrrrJs~          z*InliningInstructionTranslator.inline_call_rvrrVrWrXrrYrfuncvar7BaseUserFunctionVariable | 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)rorrvrrrsz:InliningInstructionTranslator.__init__..)r`rYrrrrrrVrWrXrYr`rrrrarrrdrrlrYr) get_globalsr>r__dict__rrinlined_code_cachernr`rYrr rrr*rr1r2rrarrdrrlrrrrrrr)rrrvrVrWrXrYrrrrcachedr`rYrr4rrr2s~          z&InliningInstructionTranslator.__init__rcCs|jjSr)rrrrrrrsz'InliningInstructionTranslator.fake_modecCst|jSr)rrrrrrrrrrIz)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)rrrrrrr1rr4rrrs   z:InliningInstructionTranslator.should_compile_partial_graphrr+rrrcs(tjr t||StdddgddS)NzGraph break in inlined functionrz2Graph breaks in an inlined call are not supported.r)rrr1rr9rr4rrrs z3InliningInstructionTranslator.create_call_resume_atcCs||_d|_tr)rrrr(r0rrrros z*InliningInstructionTranslator.RETURN_VALUEcCs|||_d|_tr)rrrr(r0rrrrps 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)rrQrr|rlr.r/rrcrLrrrNrMrDrR) rrrr r! fglobals_vt global_source globals_nameglobals_sourcerrrget_globals_source_and_value s.     z:InliningInstructionTranslator.get_globals_source_and_valuecs|j}||jvr ||S|jj|jurt|dS||\}}}|jj ||r9| |jj ||dS|j|}| t |||dSr)rarrrr2r1rrrrr.rrarb)rrrrrrryr4rrr5s   z*InliningInstructionTranslator._load_globalcsn|jj|jurt|dS|}t|tr!td|j dgd|j }| |\}}}|jj |||dS)Nz3Storing Tensor hook handle in globals (inline call)r%r) rr2rr1r(rr>rr9rarr store_attr)rrryr_fglobals_valuerrr4rrr(Fs z*InliningInstructionTranslator.STORE_GLOBAL) rrrrnrrrrUrra)rrnrr) rrrrnrrrrUrrr)rrrvrrVrUrWrUrXrrYrrrrrrrrrr)rrrr)rrrrrr rrrrrr2rrrrrrrorprrr(r6rrr4rres0   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)r1r2rrr)rrrr4rrr2]s z/InliningGeneratorInstructionTranslator.__init__racsFtjjfdd tWdS1swYdS)NcsjSrrrrrrrdszEInliningGeneratorInstructionTranslator.inline_call_..)rrrr1rrr4rrrcs$z3InliningGeneratorInstructionTranslator.inline_call_rcCrrrrrrrrgszCInliningGeneratorInstructionTranslator.should_compile_partial_graphrr+cCsR|}|j|t|jtkrtj|t dt j s"|j r'||_ tdSr)rrrrrurInfiniteGeneratorErrorr.rgrJrrrrr))rrtoprrr YIELD_VALUEks z2InliningGeneratorInstructionTranslator.YIELD_VALUEcCsF|jd}t|ts!|t|t||gi}||dSdSrl) r\r>ryrrarbrrr.)rrrresrrrGET_YIELD_FROM_ITERys  z:InliningGeneratorInstructionTranslator.GET_YIELD_FROM_ITERcd|_t|Sr)rr1ror0r4rrro z3InliningGeneratorInstructionTranslator.RETURN_VALUEcrr)rr1rpr0r4rrrprz3InliningGeneratorInstructionTranslator.RETURN_CONSTc Cst|jdks J|}|jd}|stdddgdz||}Wn.ttjfyS}zt |tjr;t ||| t |jWYd}~dSd}~wwt |jtr_|jdksaJ|jd8_| |||dS) NrrlUnreachable sub-generator coder@Should only be encountered while implementing generator support.rrr)rr\rrr9rhrirrjr>rr.rgrJryrrrrrr=rexrrr YIELD_FROMs2      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) NrrlrrrrrzSEND with bad typez TOS type: z(Attempted to SEND with unsupported type r=)rr\rr>rxrprry collectionsabcIteratorrrhrirrjrBrr.rgrJrr9r_rrrrSENDs>      z+InliningGeneratorInstructionTranslator.SEND)rrrrrrrrr)rrrrr2rrrrrorprrr6rrr4rrYs     &r)rrrr)rr )rrrr)r*r+rr,)r;r<rr)rErrr)rrr[r\r.rrr)rirjrr)rx)ryrarzrrr)r[r\r.rrr)rrrr0rrrr)r.rrrrr)rr@rvrrrrr(r __future__rrcollections.abcrWrrrTr8rr5rrrr^rrB threadingrrr?rrtypingrrrrrr typing_extensionsr r|torch._loggingtorch._dynamo.dynamo_profilerr r torch._dynamo.excr r torch._guardsrrrtorch._logging.structuredr%torch.fx.experimental.symbolic_shapesrtorch.utils._functoolsrrrrrr rrbytecode_analysisrrrrbytecode_transformationr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/codegenr0comprehension_graph_breakr1r2r3r4r5r6r7r8r9r:r;funcname_cacher<guardsr=r> output_graphr?r@rA polyfillsrBrCrDrErF replay_recordrGrHrrIrJrKrrLrMrNrOrPrQrRrSrTrUutilsrVrWrXrYrZr[r\r]r^variables.baser_r`ravariables.builderrbrcrdvariables.builtinrerfvariables.constantrgvariables.ctx_managerrhrirjrkrrmvariables.functionsrnrorprqrrrsrtvariables.iterruvariables.lazyrvrrwrxryrzr{r|variables.miscr}r~rrrrrvariables.nn_modulerrvariables.setsrrrvariables.tensorrrrvariables.torch_functionrrvariables.user_definedrrrrrrrrtorch._subclasses.fake_tensorrrlr getLoggerrrrgetArtifactLoggerrrrrrrZrrrcontainsrrrrrcacher dataclassrrrrrrrXrrrrrrr(r)r:rDrZrhrrwrrrr&rr'r7rr-r_nb_opsryrrrrrrrsZ        D   0 ( ,   $  $             L     "    * !  C " ! c/# =w