^jL  UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZmZddlmZmZmZmZmZm Z ddl!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/m0Z0dd l1m2Z2dd l3m4Z4d dl5m6Z6m7Z7m8Z8mZ9m:Z:m;Z;d dlZ>m?Z?m@Z@d dlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQd dlRmRZRd dlSmTZTd dlUmVZVd dl7mWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZad dlbmcZcd dldmeZemfZfd dlgmhZhmiZimjZjmkZkd dllmmZmmnZnmoZompZpd dlqmrZrmsZsd dltmuZumvZvmwZwd dlxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZd dl:mZmZd dlmZmZmZmZmZmZmZmZmZmZd dlmZmZmZmZd dlmZmZmZd d lmZmZd d!lmZd d"lmZmZmZmZd d#lmZd d$lmZmZmZmZmZmZmZmZd d%lmZmZd d&lmZd d'lmZmZmZmZmZd d(lmZmZmZmZmZmZd d)lmZmZd d*lmZmZmZmZd d+lmZd d,lmZd d-lmZmZmZd d.lmZmZd d/lmZmZmZmZmZerdd0lmZmZdd1lmZd d2lmZejeޫZe#jjed3Ze#jjed4Ze#jjed5Ze#jjed6ZejZeːjDcic]\}}|e|jc}}Zd7ed8<eejjZeejjZd9ed:<d;ed<<e;jrezezZd=ed><e jdrd?ZejGd@dAZejGdBdCZejGdDdEZejGdFdGZGdHdIZe jdsdJZej dtdLZej dtdMZejGdNdOZGdPdQeZGdRdSeZGdTdUeZdudVZdvdWZe jdwdXZ dxdYZdZZdyd[Zdzd{d\Z d|d]Z d}d^Z d~d_Z dd`Z GdadbeZejGdcddZGdedKefZGdgdheZej&dik\r9e j(Dcgc]\}}eedj|vr|dkdndl|dkd!c}}Zej ddmZGdndoeZGdpdqeZycc}}wcc}}w)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) defaultdictdeque)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_swapget_call_callable_depth 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_dynamoraise_value_errorResumePrologueTracingErrorStepUnsupported unimplemented Unsupported UserError) get_funcname) GuardBuilder install_guard) CodeOptionsGraphCompileReason OutputGraphStackLocalsMetadata)impl_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_kwargsunpack_iterable)SourceLocationtypestrValueMutationNewVariableTracker)FrameStateSizeEntryVariableBuilder wrap_fx_proxy)BuiltinVariableDictBuiltinVariable)ConstantVariable)ContextWrappingVariableGenericContextWrappingVariableWithEnterFunctionVariableWithExitFunctionVariableConstDictVariable)BaseUserFunctionVariable CO_VARARGSCO_VARKEYWORDSLocalGeneratorFunctionVariableLocalGeneratorObjectVariableNestedUserFunctionVariableSkipFunctionVariableUserFunctionVariable)IteratorVariableMAX_ITERATOR_LIMIT)LazyVariableTracker)BaseListVariableListIteratorVariable ListVariable SliceVariable TupleVariable) CellVariableExceptionVariable NullVariablePythonModuleVariableTracebackVariableUnknownVariable)NNModuleVariableUnspecializedNNModuleVariable) generic_boolgeneric_containsgeneric_getitervirtual_iterator_next) SetVariable)SymbolicStreamState)supported_comparison_opsSymNodeVariableTensorVariable)SymbolicTorchFunctionStateTorchFunctionModeVariable)RemovableHandleVariableUserDefinedClassVariable!UserDefinedExceptionClassVariable"UserDefinedExceptionObjectVariableUserDefinedObjectVariable)Callable Generator)FakeTensorMode)CompilePackage graph_breaks trace_call trace_sourcetrace_bytecodedict[str, Any]compare_op_handlersc2t|gt|iSN)handle_containsreversedtxargs_s i/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/_dynamo/symbolic_convert.pyrs(4.21inc Jt|t|gt|igiSr) handle_notrrrs rrrs(J.x~. 34b5rznot inr ExceptionValsc,tj|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)names r_import_modulers  " "4 ((rcpeZdZUded<ded<ded<ded<dZd ed <d Zd ed <d Zded<ddZddZy )SpeculationEntrystrfilenameintlinenoinstruction_pointerr.instFbool_failedNz bool | Noneerror_on_graph_breakzGraphCompileReason | Nonereasoncd|_||_|j|jj}nd}tj|)z\ Start tracing of the current frame over again, and don't take this branch. Tz!Unknown fail_and_restart_analysis)restart_reason)rrrrSpeculationRestartAnalysis)selfrrs rfail_and_restart_analysisz*SpeculationEntry.fail_and_restart_analysis sB $8! ;; "![[//N@N,,NKKrcn|jr)|j td|j|_yy)Nz9expected self.error_on_graph_break is not None to be trueTF)rrAssertionError)rrs rfailedzSpeculationEntry.faileds; <<((0$O'+&?&?B #r)rrreturnNone)rInstructionTranslatorBaserr) __name__ __module__ __qualname____annotations__rrrrrrrrrsCM K GT(,+,(,F %, LrrceZdZUdZej eZded<dZ ded<dZ d ed <ej eZ d ed <dZ d ed <ddZ ddZ ddZy)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_cd|_yNr)rrs rrestartzSpeculationLog.restart8s  rcF|jjd|_yr)rclearrrs rrzSpeculationLog.clear;s  rc6t|j|jk(r'|jjt |||||j|j}d}|jdk7r]|j|jdz }d|j d|j d|jjd|jd }|j|k(r|j |k(r|j |k(std |jd t|jd |j d|j d |jjd |jd|d|d |jd |d|d|xjdz c_|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_entrys rnextzSpeculationLog.next?s t||  * LL   63FM  TZZ( ::?djj1n5J()<)<(=Qz?P?P>QJOO**+3z/M/M.NcS   % %)< <(* &*""&**ZDLL8I7JK ^^ Aell^2ejj.?.?-@HaHaGbc *AfXR }G4G3HI   ( a  rNrr) rrrrrrrr.rr)rrr__doc__ dataclassesfieldlistrrrrrrrrrrrrrr"s'8k&7&7&MG #ME3N*/ $..?k.?.?PT.U )U+0!4/--%(-?B-JU- -rrcFeZdZUejeZded<ddZy) LocalStaterzdict[str, FrameStateSizeEntry]automatic_dynamiccbdjd|jjDS)N c3LK|]\}}|d|jyw): N)render).0kvs r z$LocalState.render..vs* %)QqcAHHJ<  s"$)joinritemsrs rrzLocalState.renderus/yy -1-C-C-I-I-K   rNrr) rrrrrdictrrrrrrrros%8I 8I8I95 rrc0eZdZUded<ded<dZded<y)DistributedStater compile_pgr local_stateNzlist[LocalState] | None all_states)rrrrr rrrr r |sO*.J'.rr cneZdZUeZded<eddZed dZed dZ ed dZ y) TensorifyStatezset[str]force_specializationsc:|jj|yr)raddclsrs r specializezTensorifyState.specializes !!%%e,rc||jvSr)rrs rshould_specializez TensorifyState.should_specializes1111rc8|jjyr)rrrs rrzTensorifyState.clears !!'')rc2t|jdk(Sr)rrrs remptyzTensorifyState.emptys3,,-22rN)rrrr)rrrrrrr) rrrsetrr classmethodrrrrrrrrrs_'*e8+--22**33rrc4tjtSr)torchdynamo_loggingget_step_loggerlogrrr _step_loggerr"s  . .s 33rrc#DK|jj}|jj} g|j_d|j_d||j_||j_y#||j_||j_wxYwwr)speculation_logrr)rrrs r save_and_restart_speculation_logr%s  ((G    $ $E)%'"#$  %,"#( &-"#( s-B &A9#B 9$BB c#K |jj}d|j_d||j_y#|j_wxYwwNF)output should_exit)rtmps r(temporarely_allow_writes_to_output_graphr+sA$ii## %  #  sA+AAAAc^eZdZUded<ded<ded<dZded <d d Zdd Z dd Zy)BlockStackEntryr.rzInstruction | Nonetargetr stack_indexNz?ContextWrappingVariable | GenericContextWrappingVariable | None with_contextc|jduSr)r0rs r can_restorezBlockStackEntry.can_restores  ,,rc<|j td|jrbt|jdrL|jjr6t |jdz t |jjSt |jdz S)Nz0expected self.stack_index is not None to be true target_valuesr)r/rr0hasattrr4rOtuplers r resume_fnzBlockStackEntry.resume_fns    # !ST T   ))?;!!//  1$eD,=,=,K,K&L t//!34 4rc|j td|r|jjs|s|jj|Sy)Nz1expected self.with_context is not None to be true)r0rexit_on_graph_breakexit)rris_graph_breaks rr:zBlockStackEntry.exitsM    $ !TU U t00DDF$$))"- -rr)rrO)rrr;rrVariableTracker | None)rrrrr0r2r7r:rrrr-r-sH  TXLQX- 5 + =A   rr-c eZdZy)rNrrrrrrrrrrc eZdZy) ReturnValueOpNr>rrrrArAr?rrAceZdZdZy) YieldValueOpzY Signal to the symbolic tracer to stop and return control flow to the caller N)rrrrrrrrCrCsrrCcttj|jt |t j |dfd }|S)Nch|jj||jiyr)push call_functionpopn)rrfn_varnargss rimplzstack_op..impls' &&&tTYYu-=rBCr)rInstructionTranslatorrr.rr)rinspect signature parametersrk functoolswraps)fnrKrIrJs @@rstack_oprSsL !!"%00 1E R F__RDD Krct|tjsy|jj ddt j vS)NF.r) isinstancetypes ModuleTypersplitsysstdlib_module_names)mods r is_stdlibr]s: c5++ , <<  c "1 %)@)@ @@rc|rdd}ndd}tj|Dcgc]}|j}}tdt |D}|j d}||dz|dzScc}w)Nc|sJdy)Nmsgrxs rrRz(get_assert_bytecode_sequence..fns OeO1rc |sJyrrras rrRz(get_assert_bytecode_sequence..fn s H1rc3JK|]\}}|jds|yw)POP_JUMPN) startswith)rirs rrz/get_assert_bytecode_sequence..sV71d$//*:UQVs## RAISE_VARARGSr)rbrrr)disget_instructionsrr enumerater)with_msgrRrinsts begin_idxend_idxs rget_assert_bytecode_sequencerpsr  &)%9%9"%= >TT[[ >E >Vi&6VVIkk/*G Q1 -- ?sA/c|tjus|ryt|jts t d|j}dD]}t |}|j||t|z}|Dcgc]}|j}}||k(sH|r.|jd}|j||zj} nd} |jtj|| yycc}w)NF=expected isinstance(self.instruction_pointer, int) to be true)FT LOAD_CONSTzassertion errorT)operatortruthrVrrrrp instructionsrrrargvalrFrgbuild) rtruth_fnrFcurrent_instruction_pointerrl assert_insts cur_instsrload_const_idx error_msgs r&_detect_and_normalize_assert_statementrs &4 d.. 4 K  #'":":!3H= %% '*E,+  .77TT[[7 7  $!-!3!3L!A --/.@&. IIo++D)< =!$ 8s6C,Fc|jjddxs t|dd}|sy|jj d}d}t |D]'\}}|jj ds&|})|dkry||j}d}|dzt|kr||dzj}||rd|zSdzS) zIExtract the innermost user source location from an FX node's stack trace. stack_tracerrzFile rrz, code: )metagetgetattrstriprYrkrfr)nst trace_lines last_file_idxrgline file_linecodes rget_node_source_inforfs M2 & G'!]B*GB ((*""4(KM[)4 ::< " "7 +MqM*002I Dq3{++=1,-335[$xv. ??B ??rc t|tsy |jj}ggt d dd  fd  |ssyg}t t zD]$}|j||jd&ddjd|DzS#t$rtjdd YywxYw) 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.rcxt|tjjr |jSt |Sr)rVtorchfxNoderrepr)as rfmt_argz0format_tensor_computation_trace..fmt_args&'588==9166 FtAw Frc(|j vry j|jt|}|jdk(rUg}|r|j d||j |jd|j d j |y|jdk(rt krt|j dt|j }djfd|jD}g}|r|j d||j |jd |d |dj ||jD]/}t|tjjs( |1yyy) N placeholderz# z: graph input ()rGrz, c3.K|] }|ywrr)rrrs rrz@format_tensor_computation_trace..walk..s$@AWQZ$@sz = r)rrroprr.rrrrrrVrrr) rsourceblock target_nameargs_strrr max_lines op_blocksplaceholder_blocksvisitedwalks rrz-format_tensor_computation_trace..walksMvv  KK )!,Ftt}$LL2fX/ xqxxjBC"))%0tt&3y>I+E%ahh CMJ 99$@$@@LL2fX/ xs;-q !DE  ' A!!UXX]]3Q ,F&rz@ The branch condition involves a tensor computed as follows: rc3&K|] }d| yw) Nr)rrs rrz2format_tensor_computation_trace..s<$$tf  0:`). Dynamo does not support tracing dynamic control flow.gb_typecontext explanationhints)rrVrrrrrdimdtyperint32int64rrrr.rrrr FUNDAMENTALr=)r trace_inforrexamplers rraise_jump_graph_breakz,generic_jump..raise_jump_graph_breaksj4U;  e^ ,. {{''))--8' *    LL4' * 3LLZ&dkk:tD#-dkk3#?DKKT"MMLL5  &223 HI.-eW5DFPQ    sDF F Fc p|js tdd}  || td|j r|j |j ||j|jt|||j|tjd|jj|tdt!|||j#gd}|j%|j'|j(|} r|j||j* td|j'|j*|}t,j.d k\r%|jj1t3d gt3|j4|d  } |j6 |jj8j:n|} | j=| |jj1| g|z|zy#ttf$r }|}Yd}~d}~wwxYw) Nz7expected self.should_compile_partial_graph() to be truez#expected exc is not None to be truerrzgeneric_jump triggered compilez generic_jump rr stack_pops+expected inst.target is not None to be true TO_BOOLr)r.)should_compile_partial_graphrr>r?maybe_has_backedgeraise_loop_graph_breakf_codelog_graph_break code_optionsrrFr!rr(compile_subgraphrDre frame_summarypopcreate_call_resume_atnext_instructionr.rZ version_infoadd_output_instructionsr(rparentroot_txcurrent_instructioncopy_positions) rrr extra_msgreall_stack_locals_metadataif_nextif_jump jump_instpositions_instrFrs rjump_graph_breakz&generic_jump..jump_graph_breaks 002 I   "5 ) ; !FG G  " " $  ' ' S 9    s8  % 23$(KK$@$@ %/ {;d>P>P>R=S %A% !  ,,  ! ! %   IIe  ;;  !NO O,, KK %    w & KK / /1CI1N0O P&t{{71:F 8<{{7NDKK   3 3TX    0 ++YK',AG,KLgY' C sHH5(H00H5c |j}tjr`tjj dk(rBt | r4|j}|jrmt|jr|j|S|jr  |||ytdd|dgtjddd|jrJ|j j"d t$j&gt)||fi|j|yt+|t,r|j.}t+|t$j0s|dk7}t$j2j4j6j9|}|s(td t;|d gtj<|j|y|j j"d t$j>gt)|fi}tA||tC|jD| }|j j"d t$j&gt)||fi|j|y|jrt+|tFr>|jHr2tK|jHjMtNjP|jr% r|jS||j|yy|jr|jr  |||yt+|tTrS|j jW|jX}|r% r|jS||j|yyt+|tZrt]||}|jr;|jr r|jS||j|yt+|t,r;|j_r; r|jS||j|ytd d|d|dgyyyt+|t,r t+|j.t$j0r|j_|j } nta|j.dk7} | r% r|jS||j|yy|js:t]||}|r% r|jS||j|yyt+|tfjhr.dr% r|jS||j|yyddl$m5} |jHN| |jHr<|jmr% r|jS||j|yy|y#tbjd$r*} |jr |||d| cYd} ~ Sd} ~ wwxYw)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).rrGz#Assertion failed on symbolic shapesr)rz3Data-dependent branching with non-constant __bool__z , result: zdAttempted to perform data-dependent branching on a user-defined object with non-constant truthiness.r)rTr)is_constant_source)7rr rewrite_assert_with_torch_assertrZflagsoptimizeris_python_constantras_python_constantjumprr=rr is_tensorr( create_proxyr _assert_asyncrbrVrsym_numSymBoolr experimentalsymbolic_shapes expect_truer USER_ERROR scalar_tensorrjr\rrsrrB make_guardrASEQUENCE_LENGTHrFr get_submodule module_keyrr evaluate_exprrrr?rBackwardHookVariablerget_real_value)rrrr~sym_exprresultscalar_to_tensor_proxyscalar_to_tensorr\ eval_resultrrrrFrrys rinnerzgeneric_jump..inner?sS!%  3 3 ""a'6tXtL)-I'')002399T?*668$T47! `")% 1%H.::u ;  N  * ( ((#'''y'92>  $%1!==!(EMM:'1}H..>>JJ8T! E #H $&= 1 < <=   $%=T[[%=%=!4!4&7H%SU7V& " -&,-C-H-H$O   %DKK $ $## #$4i#@"E  IIdO   # # %%!23 ell55l6R6RST0023IIe$ $4__ 4#D#D#F T4 / / 0++++E,<,<=C}IIe$ $8 9!$.F((*F5578 %(IIdOFO4F0023 %(IIdOQ%eWJvh?!;  4 9" /  emmU]];"'"5"5dkk"BK",U]]a-?"@K  $IIe$ $%"!$.FIIe$ $ y== >~IIe$ $ 3||',>u||,LE0023 %(IIdO4 'u-9== 446+D$2aSRR s%AXYX?8Y>X??Y)rrgrr)r) rrrr.rrgrrrrrrrr.rrr)ryrFrrrs`` @@r generic_jumprsb; B AM'AMAMAM AM  AMF`.`.D LrcZg}|}| |j||j}| t|D]}|jD]}t |j t r:|j|jj|j|W|j tdt |j ts td|j j||j|jj|j|y)zsGenerates bytecode to restore the block stack for running the unsupported instruction in the compiled bytecode.Nz.expected b.with_context is not None to be truezIexpected isinstance(b.with_context, (ContextWrappingVariable)) to be true)rrr block_stackrVr0r extend_outputr7try_except_torch_function_moderrrnreconstruct_type try_finally)rcgcleanupall_txescur_txbs r_reconstruct_block_stackrs  13H/1F    x R RA!..*CD  KKM@@ ~~%$%UVVann/FH$_ NN + +B /   Q[[]66rP Q% RRrc^ddlfd}|jj|||_|S)aCreate a wrapper for warnings.warn that reports the given source location. When warnings.warn (stacklevel=1) inspects its caller frame, it sees the wrapper's code object -- whose co_filename and line table point to the original leaf-frame location. This preserves Python's per-location warning dedup even when the call is inlined into a different frame by nested graph breaks. rNc(j|i|Sr)warn)rkwargswarningss rrz-_make_warnings_warn_wrapper..s-(--:XQW:Xr) co_filenameco_firstlineno)r__code__replace)rrwrapperrs @r_make_warnings_warn_wrapperrs;#YG''//0G Nrc  dfd }|S)Ncjtjdfd } dfd |S)Nc 4|j}|_|j}|j|r+|j t d|||jS ||||_S#t t f$rd}|jrg|js |jrt|t r|jtdd|jddgtj|t|ddr|j!s|j#r|j%|j&||j)|j*d t-|| t|t r!|j|j/d t1t|d t-|t|d |j3g|_Yd}~nd}~wwxYw ||_n #||_wxYw|j5|jy)Nz2expected speculation.reason is not None to be truez0Graph 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_breakr` real_stack)current_instruction_push speculaterrrr>r?active_generic_context_managers one_graphrrVremove_from_statsr=rCAUSED_BY_EARLIER_GRAPH_BREAKrrrrrrrr add_to_statsrDrr) rr prev_push speculationexcphandle_graph_breakinner_fn msg_prefixrFs rrz>break_graph_if_unsupported..decorator..wrapper's55I,0D )..*K!!$'%%-(L*$k6H6HII. :d+Z1:-Y +* 77~~)B)B"$ 4..0! R"CDDhDhCi j%Dc.LL"& 4u588:**,// TB$$%%(\s4yk:% dK0**,%%m4%7D%T3D,1C1C1E0FG& ""O* N# 1:- -  1 1$2K2K Ls+"A22G&EG!G2!G&&G22 G;c*tjdk\rtjdkrs|jdk(rdtjtj d|j tjtj d|j z}n*tj|j|j }|j|j|tjd|j|jj||t |z }t|jj }g}t#||||jj%|j'~|j |jj j(n|}tjdk\r|jdk(r|j*|j*j-nd}t/|dkDrEtjd ks t1d |jj%t3d | g|j t1d t5|j d} | dj7||jj%| n`|j8 t1dt;j:|} d| _| j7||jj%| g|jj%||j?t |z  r|jAtC|jj%|jE|jF|y)Nr r CALLPRECALLz%s triggered compilerrrrz.expected sys.version_info < (3, 13) to be trueKW_NAMESrw(expected inst.arg is not None to be trueFrz'expected inst.target is None to be true)$rZrrri stack_effectopmapargopcoder%_maybe_replace_warnings_warn_on_stackr!rr(rrr3rrrrjrkw_namesrrrr(r$rr.copy exn_tab_entryrHrFrrr) rrrr?rrrrrD call_insts inst_copyrFs rr2zIbreak_graph_if_unsupported..decorator..handle_graph_breakds   G+$$w.KK6) #//IIi($(( $$SYYv%6A B  #// TXXF {{&::4@ II,dkk :(, (D(DVD L0H)E) %4;;../B)+G $T2w 7 KK / /0C0C0E F;;* ##77  7*t{{f/D}}0MM446 x=1$,,w6,LKK77+JxHI88#()STT1$((EB 2--n= 33J?;;*()RSS IIdO *. '((8 33YK@ KK / / 8 IIc$i,. / /+, KK / /**))- rr)rrrr.rrDrr)rPrQ)r3rr2r4rFs` @r decoratorz-break_graph_if_unsupported..decorator$sY  ": M #: MxR +R R 'R  R hr)r3Callable[..., None]r8Callable[[InstructionTranslatorBase, Instruction], None]r)rFr4rIs`` rbreak_graph_if_unsupportedrLs$ T%T ATl rc$eZdZdZdfd ZxZS)BytecodeDispatchTableMetazTInstalls a `cls.dispatch_table` on every subclass to speed up calls to self.OPCODE()c @t ||||dd}tjj Dcic]'\}}|t ||t j||)}}}tdDcgc]}|j|c}|_ ycc}}wcc}w)Nc^td|d|d|dd|dgtjy)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)r=r SUPPORTABLE)rrs r_missingz4BytecodeDispatchTableMeta.__init__.._missingsS 2!(+dV4[\b[ccef;F8D__'22 r)rrrrrr) super__init__rir@rrrPpartialrangerdispatch_table) rrbasesdctrSrrrYrg __class__s rrVz"BytecodeDispatchTableMeta.__init__s uc* "iioo/  VY%6%6x%HI I  >C4[In003I  Js ,B4B) rtyperrrZrr[rrr)rrrrrV __classcell__r\s@rrNrNs^JJrrNceZdZUdZej eZded<ej dZ ded<dd Z d dd Z dd Z dd Z dd ZddZ ddZddZddZddZddZddZeZy)ExceptionStackzU Exception stack that it is shared among all InstructionTranslator instances rzlist[ExceptionVals] _exc_stackN)defaultzExceptionVals | None_current_exceptioncd|_yr)rdrs rclear_current_exceptionz&ExceptionStack.clear_current_exceptions "&rc8|r|j|||_yr)._set_context_and_break_context_reference_cyclerd)rval set_contexts rset_current_exceptionz$ExceptionStack.set_current_exceptions   ? ? D"%rc|j td|j|j|jyNz7expected self._current_exception is not None to be true)rdrrrfrs rmove_current_exception_to_stackz.ExceptionStack.move_current_exception_to_stacks>  " " * I  D++, $$&rcH|j td|jSrm)rdrrs rget_current_exceptionz$ExceptionStack.get_current_exceptions,  " " * I &&&rc|jx}r|js|St|j|zdkDr9|j|}|j ||dz ||ur|j ||S)Nrr) __context__is_constant_nonerrb_set_context_recursiverj)rriprev_idxctxprevs rrtz%ExceptionStack._set_context_recursivess?? "C "C,@,@,BJ t ( *Q .??8,D  ' 'hl ;3% rc|x}}d} |j}|jry||ur%|jtjdy|}||ury|r |j}| }_r')rrrsrjrmcreate)rrioslow_oslow_update_togglers r_break_context_reference_cyclez-ExceptionStack._break_context_reference_cycles~ F"mmG'')#~ .55d;<AF{!++%7!7 %rcv|j|t|jdz |j|yNr)rtrrbr}rris rrhz=ExceptionStack._set_context_and_break_context_reference_cycle*s0 ##CT__)=)AB ++C0rc6|jjSr)rbrrs rrzExceptionStack.pop1s""$$rc:|jj|yr)rbrrs rrzExceptionStack.append4s s#rc,t|jSr)rrbrs r__len__zExceptionStack.__len__7s4??##rc |j|Sr)rb)rrs r __getitem__zExceptionStack.__getitem__:su%%rc:d|jd|jS)Nzself._exc_stack=z - self._current_exception=)rbrdrs r__str__zExceptionStack.__str__=s""$//##?t'>'>&@AArr)T)rirrjrrr)rr)rirrurrr)rirrr)rr)rrrrr)rrrrrrrrbrrdrfrkrnrprtr}rhrrrrr__repr__rrrraras'8k&7&7&MJ#M/@{/@/@/N,N'7;& &/3& &''   ,/   861 1 1%$$&BHrrac 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<dd4Zdd5Zdd6Zdd7Zdd8Zdd9Z dd:Z dd;Z dd<Z dd=Z dd>Z d dd@ZdddBZddCZddDZddEZej*dFk\rddGZnddHZed dIZd dJZd dKZddLZd dMZd dNZddOZddPZddQZ ddRZ!ddSZ"ddTZ#ddUZ$ddVZ%e Z&ddWZ'ddXZ(ddYZ)e*jVddZZ,dd[Z-dd\Z.e/dd]Z0dd^Z1dd_Z2dd`Z3e3Z4ddaZ5e/ddbZ6ddcZ7dddZ8e8Z9e8Z:e;ee;e.s  q/ * ziexpected all( isinstance(x, VariableTracker) for x in itertools.chain(args, kwargs.values()) ) to be truerrRz$Attempt to trace forbidden callable )rVrgrrrrrchainvaluesr5rrRcallablerYrFrG)rrRrrr3s rrGz'InstructionTranslatorBase.call_functions "o. !VW W$% !MN N&$' !OP P __T6==?;  !{  2w xxH 2t uuH  HX$6<;Q #Gz!RS S """4v67rc^t|ts t|}|j|||S)zD Redirect the call to the generator "call_function" )rVrwrG)rrRrrs rinline_generator_functionz3InstructionTranslatorBase.inline_generator_functions."<=/3BdF33rFctjr,t|jr|j |||St j |||||S)zF A call to some user defined function by inlining it. allow_nested_graph_breaks)r"enable_faithful_generator_behaviorr/get_coderInliningInstructionTranslator inline_call)rrRrrrs rinline_user_function_returnz5InstructionTranslatorBase.inline_user_function_returnsV  4 4bkkm9T11"dFC C0<<*C = rNc | |j}|jdkDrd|jdnd}t|jj|}|dnd|d}|jjd|d|jj ||S)Nrz (inline depth: rrrrz in )rrr@rrco_name)rrinline_depth_strfuncname funcname_strs rget_line_of_code_headerz1InstructionTranslatorBase.get_line_of_code_headers >[[F7;7H7H17Lt001 3RT   7 7@%-rRz3C ++))*!F84 8K8K7L\N[kZlmmrcd|jd}tj|jj|j j }|d|z }|S)NzTRACE starts_line rr)r linecachegetlinerrrrstrip)rlog_strrs rget_log_starts_line_log_strz5InstructionTranslatorBase.get_log_starts_line_log_strsX&t'C'C'E&FbI  !8!8$++FMMOT$= rc|j|k(ry||_tj|jj||jj |j r*tjdt|jyy)N%s) rrset_current_locrrris_trace_source_log_enabledtrace_source_logrrar)rrs r starts_linez%InstructionTranslatorBase.starts_line sl ;;&  && KK # #VT[[-@-@   + +  " "4D4T4T)U V ,rct|_|j}|y|j|x|_}|dz|_|j r|j |j t j}||j|_ |jsb|jrR|jrB|j|_|jj|r|j!|y|j"r?t$j'd|j(|j*t-|jt.j0rW t-|j}|j4j7d|j(dt-|j*d||j9| |j:|j<|||j>j@ S#t2$rd}YwxYw#tB$rtDjF$r}|jI|Yd}~yd}~wtJtLf$rYytNtPtRf$r}|jTs%|js|jVs tY|d dr2t[|tRr!t]d d d d dgt^j`|jOtbj'dt[|tRr"t]dd dd dgt^j`dd|_2dtg|}|ji|jj||Yd}~nd}~wwxYw|jjm|jy)zzTRACE  Tr%z3cannot 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)7rZrrrvrrrtry_get positionsloc_in_frame_positionsrris_non_empty_graphr)rrstep_graph_breakis_trace_bytecode_log_enabledtrace_bytecode_logrrrwrrverbose ValueErrorrrupdate_block_stackrYrBr(r)rrrexception_handlerrArCr>r?r<r+is_tracing_resume_prologuerrVr=r DYNAMO_BUGr!r%rrrr)riprtc stack_reprrrs rstepzInstructionTranslatorBase.stepsA$=$?!  % % :*.*;*;B*?? 4#%6      T-- .  # # % >(,B % 113'')'+~~'7D $''..t4%%d+  - -  $ $ $++t{{D> P!$**-   & & - - QtDKK'8&9:,G  %A  ,D   ,T4 8{{... . PO  P.  $$   " "1 %|, Y87 ,,221lE2a1! U "%`PW/99 ''/ MNa1! X "%aPk/99  $(  $ /031vh8   !! !  g7 r   ::4;T;TUs=G6?6H6 HHM#H99M M C*MMr6c|j}|rt|jdk\rg|j|jdjurA|j|jdjur|jj yyyy|jrM|j dvr>t|jdk7r t d|jj yyy)Nr)NOP JUMP_BACKWARD NOT_TAKENrz.expected len(self.block_stack) == 1 to be true)rFrr r.rrr)rrrs rrz,InstructionTranslatorBase.update_block_stacks&&E (()Q. D,<,Be2 . . & ')+G $T[["g >  $ $&6%7:J9KR P   W %    ^((+'7!^  ((+  '7  2!4>>I    ^((+++-)I6      ^&}!<  KK  _. / %a ( 2 2a 7 2 1}  $Q,,Q///1-Y=  %Q  ,,Q/ +>:    &'8i!mL&|QG&'8i!mL " KK / /##%++33KK002KAB2O  KK / / ^&y1 4;;../B KK / /((,++-  8;HHNNP  s 33&(,,S1//1.   KK / /&y1(7&& rc,tjdSr)r current_framers r run_ctx_mgrz%InstructionTranslatorBase.run_ctx_mgrs++D11rc |j5t|jj |jj ||j |_ |jr |jr|jjYt)|t.r5|jj[|jj] dddy#t$rY}|jrGtdt|jdt|j|j dd}~wwxYw#t"$rt$$rt&$r*}t)|t*t,frTt)|t.rD|j0s8|j2s,dt|}|j5|j6||t)|t8j:s$|jj<j?tA|drpd|jBvrbtDjFjI|jjJ|jjLjOddd }||_(d}~wt$ro}|jRr|jRjU|_+t)|t8j:s$|jj<j?d}~wwxYw#|jjYt)|t.r5|jj[|jj]wwxYw#1swYyxYw) 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: rr`zData-dependentFT) print_outputinclude_strideinclude_device)/r!rrrr(push_txrrrrrr;r]rrwith_traceback __traceback__rr6 RuntimeErrorrVr>r?rLrr+rrrRestartAnalysis side_effectslog_side_effects_summaryr5r`rr GraphModule nn_modulesgraphprint_readablepartial_fx_graphr get_record exec_recordpop_txrmark_bytecode_tracing_stop)rrrreadable_graphs rrunzInstructionTranslatorBase.runs    L = dkk-- .J = ##D)#'#;#;  ))+))+t ""$ d$9:KK'') KK::? 55 NN77:1vh@ (())%) "!S%8%89KK,,EEG1e$)9QUU)B%*XX%9%9 .. 0A0A&$n%*4PT%# *8A& %%$($6$6$A$A$CAM!!S%8%89KK,,EEG   ""$ d$9:KK'') KK::< ;ML =L =si M1,E!C)AM1) E 2AEE  EL *D%J L A*LL  L  A!M..M11M:c t|tstdt||j|j }|j |j j|jt|jj|j j|j j|j j|j jnF|j:|jt|jj|j|j j#|y)Nz"push expects VariableTracker, got )rr end_lineno col_offsetend_col_offset)rr)rVrgrresource_locationrrrset_source_locationrdrrr9r:r;rrr)rrirs rrFzInstructionTranslatorBase.pushs#/ #Egcl^!TU U    &++D~~)dnn.C.C.O''"!%!8!8#~~44#'>>#<#<#'>>#<#<'+~~'D'D !!-''"!%!8!8#// #rc4|D]}|j|yr)rF)rvalsris r push_manyz#InstructionTranslatorBase.push_manys C IIcN rc6|jjSr)rrrs rrzInstructionTranslatorBase.popszz~~rcpgtt|Dcgc]}|jc}Scc}wr)rrXr)rrrs rrHzInstructionTranslatorBase.popns*:uQx8!488:89::8s3 c |j}|jr7||jvr)|jj||j| |j |j |j |jd r|j j|yy#t$r|jdrh |jdd}|j |j |n\#t$r*tdd|d|ddgtjYn*wxYwtd d|d |dgtjYwxYw) NrUimplicitz5Attempted 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)rwrf_locals add_local_varrFrunwrapKeyErrorrfrr=rrr)rrrnew_names r LOAD_FASTz#InstructionTranslatorBase.LOAD_FASTsP{{   $$--"7    , ,T4==3F G  IId**40779 :4 ??9 %  $ $T * &3 s# #||C|jj|j|j|jyyy)N;expected inst.argval in self.cell_and_freevars() to be true) rwrrrr(r+ load_cellrFrrGrH)rrcell contents_vars r LOAD_DEREFz$InstructionTranslatorBase.LOAD_DEREF+s ;;d446 6 M ##DKK0{{//99$?  ,   $++">    , ,T[[$-- :T U#? rc|j}|j}|j|||j|<|tk(r4|j }t |tur td||_ yy)Nz%expected type(val) is bool to be true) rwr set_name_hintrrNrr]rrr)rrr loaded_vtris r STORE_FASTz$InstructionTranslatorBase.STORE_FAST7sp{{HHJ %%.T" 5 5..0CCy$$%LMM.1D + 6rc|j}|jj|}t|tr|j ||j|=yr)rwrrrVr_maybe_emit_sync_dealloc)rrrvars r DELETE_FASTz%InstructionTranslatorBase.DELETE_FASTBsG{{""&&t, c> *  ) )# .   &rc^ddlm}m}|j}||jdvry|j j }|jjdijdd}t|jj}|syd}|jjjD] } | |vs| } ||jdk(ry|jjdijdd} || k(ry|||}| ||} |} |jj!dt"j$j&j(| | fi|jj!dt"j$j&j*| ||j-fiy)Nr)get_current_stream new_event)cudaxpucustomstreamr(rG)variables.streamsr\r]devicer]rrrrruserskeysr(r/nodesrrropsstreams record_event sync_deallocas_proxy) rrYr\r]rcr alloc_streamrd last_userrlast_use_stream event_idxs rrXz2InstructionTranslatorBase._maybe_emit_sync_deallocIsuD >V[[? yy~~yy}}Xr266xF DJJOO%&  ""(( AEz      8 #..,,Xr:>>xN ? *   -f5L  "08OK     II   * *  (      II   * *  clln 5   rcv|j|jvr td|j|j}|j }|j j j||t|ts td|j|j|jyy)NrNz2expected isinstance(cell, CellVariable) to be true) rwrrrrr(r+ store_cellrVr local_namerT)rrrPris r STORE_DEREFz%InstructionTranslatorBase.STORE_DEREFts ;;d446 6 M ##DKK0hhj   ++D#6$ - D  ?? &   doo . 'rc|j}| tj|jS|j|}|s'>T[['QD ! !! $''*C ; !FG G rcD|j|j|yr)rFrwrs rrsz$InstructionTranslatorBase.LOAD_CONSTs $""4()rc |j}|jrw||jvr*|jj||j|n?||jvr t d|j||jj |<||jvr|j|S||jvr\|jj|j|}|j|jjj||y|j|}|jtj||t|y)Nz+expected name in self.f_builtins to be true)rwr f_globalsadd_global_var f_builtinsrbuiltins load_builtinrr(r+rF load_globalrgrxrR)rrrvariablers r _load_globalz&InstructionTranslatorBase._load_globals{{   t~~%""11$t8LMt.()VWW48OOD4I""++D1 t~~ %$$T* * 4(( ({{//0E0Ed0KLH IIdkk..::8TJ K t$ /''e\$5GHIrcld}|j|}t|}tj|||S)Nztorch.nn.modules.module) import_sourcerrgrx)r module_name module_sourcefglobals_values rnn_modules_globals_vtz/InstructionTranslatorBase.nn_modules_globals_vts6/ **;7 ' 4$$T>=IIrcJ|j tdtjdk\r3tjdkr |jdzr|j ||j |tjdk\r"|jdzr|j |yyy)Nr>r6rr)rArrZr PUSH_NULLrrs r LOAD_GLOBALz%InstructionTranslatorBase.LOAD_GLOBALs 88  !KL L   w &3+;+;g+E$((UV, NN4  $   w &488a< NN4 ,8 &rc|j}|j}t|}||jvrt |j|<|j j j||j|}t|trtd|dg|j j j|||y)Nz%Storing Tensor hook handle in globalsThis is not supported.r) rrwrRrrr(r+track_global_existingrVrr= store_global)rrrrrrs r STORE_GLOBALz&InstructionTranslatorBase.STORE_GLOBALs {{d# t,, ,*0(D ! !$ ';;++AA D))$/  e4 5 ?4     --heDrc.d|vrZtjjj|}|j ddj ddj dd}n t |}d|j dd}|j|jj ||||jj|<|jj}||vs|||us td|||<|jj|t|S) z-Create an alias to a module for use in guards torch_package>r,7 ""5)KK,, Y&)E*:e*C Y ! % ##E*E""rc~|jd|dz }t||kr td|d}|r|d|S|S)z Copied from the Cpython implementation of __import__ Resolve a relative module name to an absolute one. https://github.com/python/cpython/blob/5a094f0255eea1db58fb2cf14c200971e64ec36e/Lib/importlib/_bootstrap.py#L902 rUrz2attempted relative import beyond top-level packager)rsplitr ImportError)rrrlevelbitsbases r resolve_namez&InstructionTranslatorBase.resolve_namesQ ~~c519- t9u RS SAw#'$q1T1rc|jjd}|jjd}|6|2||jk7r#tj d||jd|S| |jStj dd|jd}d|jvr|j d d }|S) z Copied from the Cpython implementation of __import__ https://github.com/python/cpython/blob/5a094f0255eea1db58fb2cf14c200971e64ec36e/Lib/importlib/_bootstrap.py#L1090 __package____spec__z)__package__ != __spec__.parent (%r != %r)r) stacklevelzYcan't resolve package from __spec__ or __package__, falling back on __name__ and __path__r__path__rUr)rzrrr!warning rpartition)rrspecs r calc_packagez&InstructionTranslatorBase.calc_packages ..$$]3~~!!*-  Gt{{$: ?KK  N  ;;  KK8   nnZ0G/!,,S1!4rc l|jd\}}|j}|j}|j}tjd|d|d|}||j vr|j |}t |}n{ t||||j }|d k7r#|j}|j|||}|s&|jd d } |j| }n|j|}|j r|j j#|t%t&j(t*fr|j-t/|| ytd t1|dg y#t$r,tdd|d|d|dgtj YwxYw)Nrr)fromlistrglobalszImport failurez module_name: z , fromlist: z, level=z"Failure when attempting to import.rrrUrzBad import resultz%Import result is not a Python module.)rHrrwrLLOCAL_MOD_PREFIXrzrR __import__rr=rrrr partitionrr add_local_modrVrWrXrKrFrre) rrrrr recorded_namerrpkgtop_level_module_names r IMPORT_NAMEz%InstructionTranslatorBase.IMPORT_NAME s))A,x((*..0kk !112!E7!H:Q{m T  DNN *NN=1E!-0F "% NN z'')"// S%H (3(=(=c(B1(E%++,AB++K8       , ,]E B ee.. < = II*5@ A +C  A ,+K= XJhW\V]^ D9-889  sE>>1F32F3c\|j||j|jyr)DUP_TOP _load_attrrwrs r IMPORT_FROMz%InstructionTranslatorBase.IMPORT_FROMR s T  $rct||jvr#tddd|dgtj|j|}t |rBt |j j}t||}tj|||St|s tdtj||S)Nz%failed to find name in frame builtinsrzFailed to find name `z` in frame's builtins.rz,expected is_builtin_constant(val) to be true) r|r=rrrrRr(%name_of_builtins_dict_key_in_fglobalsrQrgrxrXr)rrwribuiltins_source var_sources rload_builtin_from_argvalz2InstructionTranslatorBase.load_builtin_from_argvalX s  ( ?3F8;QR&11  oof% C=* AAO+?FCJ"((sJ? ?&s+$%STT"((s3 3rcX|j|j|jyr)rFrrwrs rr~z&InstructionTranslatorBase.load_builtinp s $// <=rcN|j td|j td|j tdt j d|j|jz |j |j|_|j|_y)Nr0expected self.start_point is not None to be truerir_count)rrrr.r^ incrementindexofrs rrzInstructionTranslatorBase.jumps s  # # + J     # !ST T ;;  !NO O'' 0043C3CC $(<< #< 33rTc |j td|jjt ||jt |j yNrr.rr rr-rrrs r SETUP_LOOPz$InstructionTranslatorBase.SETUP_LOOP A ;;  !NO O dkk3tzz? STrc |j td|jjt ||jt |j yrrrs r SETUP_EXCEPTz&InstructionTranslatorBase.SETUP_EXCEPT rrc8|jjyr)r rrs r POP_BLOCKz#InstructionTranslatorBase.POP_BLOCK s rc&|j|yrsetup_or_before_withrs r SETUP_WITHz$InstructionTranslatorBase.SETUP_WITH  !!$'rc |j td|jjt ||jt |j yrrrs r SETUP_FINALLYz'InstructionTranslatorBase.SETUP_FINALLY sA ;;  !NO O dkk3tzz? STrctjdk\rQ|j}|jj}|j ||j |n/|jj}|j | tjdk\rCt ||\}}|j|j ||j |y|j |}|j |y#ttjtjf$r}t|tjtjfrtj|tjdk\r%|j tjdn|j|j|Yd}~yd}~wwxYw)Nrr8)rZrrrealizerFr next_variable StopIterationrObservedUserStopIterationObservedIndexErrorrVhandle_observed_exceptionrmryr)rr null_or_idxitrinext_rs rFOR_ITERz"InstructionTranslatorBase.FOR_ITER sW   w &((*K##%B IIbM IIk "##%B IIbM 7*24[I U  %  #&&t, #   ) )  " "   !c;;S=S=STU--d37*  *11$78 IIdOO# s AD+"D(G6BGGclt|tjtfr|j |gi}|Sr)rVrrkrrGrs r_create_exception_typez0InstructionTranslatorBase._create_exception_type s6  )++-NO ##D"b1C rc|j}|j|d}t|ttfs t dt j ||}|j|dtj|d|giy)Nr(zKexpected isinstance( tb, (ConstantVariable, TracebackVariable) ) to be true __setattr__) r var_getattrrVrmrrfrom_frame_summary call_methodrgrx)rrrtbnew_tbs r_attach_traceback_to_exceptionz8InstructionTranslatorBase._attach_traceback_to_exception s**, S__    "/1BCD ] #55mRH    " "4 96 B   rc|j|}t|jrWt|tj r=|j tur+tj|tj|gi}|j|r:t|dd-tjj j#|_|j|rd|j&j)||t+j,|j }t|dd}|d|j/|t+j0t2|d|j5gy)N python_stackrjraised exception )r'z/exceptions must derive from BaseException, not r)rr/rrVrrexc_typerrgrxr)rG_isinstance_exceptionrr_guardsr extract_stackrrrkrget_dynamo_observed_exception debug_reprraise_observed_exception TypeErrorpython_type_name)rrirjobserved_exception_typers r_raise_exception_variablez3InstructionTranslatorBase._raise_exception_variable s9))#.  %3 ; ;< -!''l;II$PRTVWC  & &s +^T2:$}};;IIKC   % %c *    3 3C[ 3 Q&)&G&G &U #"3=L)#CNN$4#56<  $$  A#BVBVBXAYZ rc j|jdk(rt|jstjt |dgt|js t d|jd}|j|s t ||j|dy|jdk(rO|jd} |j|d |jj}|j|y|j}|j} |j|d |jj}|j||j|}|j|d tj |d |giy#|jj}|j|wxYw#|jj}|j||j|}|j|d tj |d |giwxYw) NrzNo active exception to reraiser*expected len(self.exn_vt_stack) to be truerFrrTr __cause__)rArrrrr)rrrrrprrrrrgrx)rrricurr_excfrom_vtcauses rrhz'InstructionTranslatorBase.RAISE_VARARGS s 88q=t((),, $.N-O t(()$%QRR##B'C--c2$S))  * *3E * B XX]**R.C >..s.E ,,BBD33H=hhjG((*C ..s.E ,,BBD33H=33G<$$!$**4=uE  ,,BBD33H= ,,BBD33H=33G<$$!$**4=uE sF G -G A(H2c|jd}t|ts td|jt urt dddgy|j|y)Nrz6expected isinstance(tos, ExceptionVariable) to be truez CLEANUP_THROW with StopIterationrzRReceived StopIteration when handling generator.throw/close. This is not supported.r)rrVrrrrr=RERAISErrtoss r CLEANUP_THROWz'InstructionTranslatorBase.CLEANUP_THROWG sZjjn#01 H  <<= ( :p   LL rcztjdk\re|j}|jr$|j}|j |dy|j ||j |dy|j}|j}|j}|j |dy)Nr6Fr)rZrrrwrrF)rrrir_exc_tbs rrz!InstructionTranslatorBase.RERAISEX s   w &((*C{{HHJ..s.F #..s.F88:D((*C((*C  * *3E * Brc"t|tSr)rVrrs rrz/InstructionTranslatorBase._isinstance_exceptiono s#}--rcBg}tjdk\rtjdkrdnd}t|j|k\s t d|j| }|jd}|j |s t dt |j}|j|d}tjdk\rt|jd ts|j|jd nt|jd k\s t d |jd }|jd }|j |s t dt |j}|j|d}||||gz }|j||iy)Nr6rz-expected len(self.stack) >= fn_loc to be truer3expected self._isinstance_exception(val) to be truer(z(expected len(self.stack) >= 7 to be trueir) rZrrrrrrkrrrVrrrG)rrrfn_locrRrityprs rWITH_EXCEPT_STARTz+InstructionTranslatorBase.WITH_EXCEPT_STARTr sr&(   w &**W4Q!F Ov-$%TUUVG$B**R.C--c2$I"#,,/CB 7*!$**R.,?KK 2/ Oq($%OPPBB**R.C--c2$I"#,,/C7B c2 2tR(rc   d d fd }tjdk\rLjj}|rt j |j kDr3jt j |j kDr3|jr9jtjjjjjjj|yj j!jj}j#|t%t&ur|t j(rFj(j}|j*j,dk(rЉj/djjt j(dk(rYj j!t%t&ur,t1dt3 dzgt4j6 j(j}|j*j,dk(rЉjj}jj9t j |j:kDr3jt j |j:kDr3t=t?d ddd}j(jAtC|dt j t jd k\rrjd }jtEjFj|jtEjH|jJnljtMjNdjtMjNdjtMjNdjtEjFj|jtEjH|jJj|yj j!t%t&ur|)NzDynamo found no exception handler at the top-level compiled function when encountering an exception. Exception will propagate outside the compiled region.c0jj}tj|j }t |s t dtdd|jgtjtjy)Nz.bubble_exception_to_interpreter s((>>@H::8;O;O;QRJ. ;$R ,+H,?,?,A+BC7&11&22* rr6EXCEPT_HANDLERrrz#Observed exception (EXCEPT_HANDLER)z This graph break is unexpected.r#g.Arrr)(rZrrrFrrdepthrlastirFrgrxrrrprrrr]rLr rrrHr=rrrrnr/r.rrr-rrrkrrmry) rrrrFrblock_stack_entry exception_varexcept_handler_inst old_exceptionrs `` @rrz+InstructionTranslatorBase.exception_handler s d $  &   w & 44BBM $**o (;(;;HHJ$**o (;(;;!&&II'--dD4L4L4S4ST  $++AACD -(   " ,,BBD33H=:!6635&&4##$%)$4$4$8$8$:!',,337GGIIaL%%))+4++,1 ((*:)>>)(M(+,<(=,G"D-E&E(9(D(D&E)9 /.(,(8(8(<(<(>%)(,,337GG,!% 1 1 G G I !!AAC$**o(9(E(EEHHJ$**o(9(E(EE '2#c( 0 to be truerr zYBug in Dynamo tracing of exception handling.Top of the block stack is not EXCEPT_HANDLER.r) rZrrrrrr rrrH)rrrs r POP_EXCEPTz$InstructionTranslatorBase.POP_EXCEPTC s   w & At(()$%QRR    ! ! #(()A-$%TUU#((//3CC$D    " IIaLt(()$%QRR    ! ! #rct|jdk\s td|j}tj dk\r|jd}n|jj}t |ttttfs,tdt|d|dgtjtj dk\r=|j|s,td t|d |dgtjt |tr |j }n|g}|D]}t |tttfs,td t|d |dgtj|j|r"t#|j$|j&ry t |t(jst#|j&|j&sy y)Nr(expected len(self.stack) >= 2 to be truer6rz Exception with bad expected typez"`except ...` has unsupported type rUrzCaught 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)rrrrrZrrVrkrrrr=rrrrr issubclassrrRr)rexpected_exc_types exc_instanceexpected_types expected_types rcheck_if_exc_matchesz.InstructionTranslatorBase.check_if_exc_matches[ sDJJ1$ !KL L!XXZ   w & ::b>L  ::>>+L 12    :./@AS@TTUV5)445     w &--l;8 -"efresst u9-889  (- 8/55N#N, M#65A ."CM?RS T9-889  )),7J%%  =L)*C*CD  J 3 6rcj|jtj||jyr)rFrgrxr3rs rCHECK_EXC_MATCHz)InstructionTranslatorBase.CHECK_EXC_MATCH s$ /''d.G.G.IJKrcH|js|j|yyr)r3rrs rJUMP_IF_NOT_EXC_MATCHz/InstructionTranslatorBase.JUMP_IF_NOT_EXC_MATCH s((* IIdO+rz`Encountered graph break when attempting to trace COMPARE_OP: a comparison operation, e.g. a == b)rFr4c|jdk(r|j|y|jt|j||j diy)Nzexception matchr)rwr5rFrrHrs r COMPARE_OPz$InstructionTranslatorBase.COMPARE_OP sF ;;+ +   & II)$++6tTYYq\2N Orctjdk\r|j}t|tt fr7|j ||j tj|dy|jtj|t|gi|j ty|jtj|t|jgiy)Nrr) rZrrrVrrrFrgrxrGiterrrrobjs rGET_ITERz"InstructionTranslatorBase.GET_ITER s   w &((*C# m<= # ///a89""?#8#8t#DseRP ,.)   44T4@488:,PR SrzjEncountered graph break when attempting to trace CALL_FUNCTION: a call to a regular function, e.g. f(x, y)c|j|j}|j}|j||iyr)rHrwrrG)rrrrRs r CALL_FUNCTIONz'InstructionTranslatorBase.CALL_FUNCTION s3 yy% XXZ 2tR(rzjEncountered graph break when attempting to trace CALL_FUNCTION_EX: a variadic function call, e.g. f(*args)c n|jdk(rti}|j}n|jdk(stjdk\r<|j}t |t r ti}|j}n9tdd|jd|jgtjtjdk\r+|j}t |t s td |j}tjd k\r>tjdkr+|j}t |t s td t tstt||}t trtj |t"|}t |trt |ts7td d t%|d t%|dgtj&|j)}|j+||j,|y)Nrrrz%Variadic function call with bad flagszflags: zHAttempted to call a variadic function (CALL_FUNCTION_EX) with bad flags rrz2expected isinstance(null, NullVariable) to be truer6z0Variadic function call with bad args/kwargs typez args type: z, kwargs type: z2Expected args to be a list and kwargs to be a dict)rwrsrrZrrVrr=rrrrrrcrrlcall_custom_dictrrerkeys_as_python_constantrGr)rr kwargsvarsargsvarsnullrRs rCALL_FUNCTION_EXz*InstructionTranslatorBase.CALL_FUNCTION_EX s ;;! *2.JxxzH [[A !1!1W!<J*l3.r2 xxzH ?!$++/fgkgrgrfst5)445     w &88:DdL1$HXXZ   w &3+;+;g+E88:DdL1$H   %_T8%DEH j"; <,==dD*UJ($45Z  > J%gh&7%8PZH[G\]P5)445   779  2x~~z:rzyEncountered graph break when attempting to trace CALL_FUNCTION_KW: a function call with keyword arguments, e.g. f(x=True)c|j}|j|j}|j}t|ts t d|j s t d|j}|dt| |t| d}}tt||}t|t|k7r t d|j|||y)Nz7expected isinstance(argnames, TupleVariable) to be truez1expected argnames.is_python_constant() to be truez0expected len(kwargs) == len(argnames) to be true) rrHrwrVrrrrrrziprG)rrargnamesrrR kwargs_listrs rCALL_FUNCTION_KWz*InstructionTranslatorBase.CALL_FUNCTION_KW s 88:yy% XXZ(M2 I **, !TU U..0 !1CM>2D#h-9I4Jkc(K01 v;#h- ' !ST T 2tV,rc(|jtj|d|jd}|jd|}t j dkr|j|y|jtj||y)Nrr=rco_namesr6) r@rrrwrrZrr LOAD_METHODrrrArws rLOAD_METHOD_SUPERz+InstructionTranslatorBase.LOAD_METHOD_SUPER1 st ;..tA>?kk!n"":.s3   g % OOF #   [00fE Frc|jtj|d|jd}|jd|}|j |y)Nrr=rrN)r@rrrwrrrPs rLOAD_ATTR_SUPERz)InstructionTranslatorBase.LOAD_ATTR_SUPER: sK ;..tA>?kk!n"":.s3 rcF|j|j|j}tjdk\r#|j ||j |ytjdk\r#|j ||j |ytd)Nrr6zPLOAD_METHOD should have been rewritten to LOAD_ATTR. We should never reach here.)rrwrrZrrFrrr<s rrOz%InstructionTranslatorBase.LOAD_METHOD@ sy  $hhj   w & IIcN NN4    ( NN4 IIcN b rctd)Nz^CALL_METHOD should have been rewritten to CALL_FUNCTION. This function should never be called.)rrs r CALL_METHODz%InstructionTranslatorBase.CALL_METHODQ s l  rc|j}tj|tj ||tj||gi}|j |yr)rrgrxrrGrF)rattrr=rs rrz$InstructionTranslatorBase._load_attrV sShhj &&tW5CC  /''d3 4   &rctjdk\r!|jdzr|j|y|j |j y)Nr8r)rZrrArOrrwrs r LOAD_ATTRz#InstructionTranslatorBase.LOAD_ATTR_ s<   w &xx!|  &  $rzkEncountered graph break when attempting to trace STORE_ATTR: storing an object's attribute, e.g. x.attr = yc|jd\}}tj|tj ||tj||j |giy)Nr)rHrgrxsetattrrGrw)rrrir=s r STORE_ATTRz$InstructionTranslatorBase.STORE_ATTRg sQ 99Q<SdG,::  /''dkk:C @  rc|j}|j||jtj|t j ||tj||jgiyr)r_maybe_sync_dealloc_attrrwrgrxdelattrrGr<s r DELETE_ATTRz%InstructionTranslatorBase.DELETE_ATTRs s[hhj %%c4;;7dG,::  /''dkk: ;  rc|jjj||rI|jjj||}t |t r|j |yyyr)r(r+has_pending_mutation_of_attr load_attrrVrrX)rr=rattr_vars rr_z2InstructionTranslatorBase._maybe_sync_dealloc_attr| s] ;; # # @ @d K{{//99#tDH(N3--h74 Lrcg}|dks td|dk(r|jtd|jdk(r t dnt d|j }|jt dt d|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. rz"expected num_stack <= 1 to be truerrrr=r)rrr+rr(rw)rrrm return_insts rcodegen_return_with_popsz2InstructionTranslatorBase.codegen_return_with_pops sQ !EF F > LLQ ({{n, ~ .#N4;;G    *,>y,I; W  rcx |rt|j|jD]\\}} } ttj | } |j t| j||jgtd|j||j|j|td|jD]\} } ttj| } |j t| j||jgtd|j||j|j|j |j"| ztdt%|r#|j&s t)d|j&}t+d|j,} |rlt/j0|t3fdjD}t5|j6t3fd|D}t3fd|D}|jt|j||jtg|D]`}|jt|j|j |j"|z|jgtdb|jtdtd t9| gtdt;|j d d n8t3|j"j=}t3|j6}t>j@d krt9|dk7r t)dt9j t9|jBz }jDj, t)dtGjHjJjLjDj,|j,t3djND|||t3djND|t3|jt3|jt3|jBt3|jP }tSjTjJjWdd}|+tYjZ|tSjT|d<j\j_| |j`jb*jbje|j`d| tfd|jhxxdz cc<|| 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 z&expected resume_inst.target to be true __resume_at_c3NK|]}|vr|jvr|ywr)r)rrrrs rrz:InstructionTranslatorBase.create_resume.. s0!:!4+A+A+C"C!s"%c3,K|] }|vs| ywrrrrargnames_null_sets rrz:InstructionTranslatorBase.create_resume.. sS1AR8RQS c3,K|] }|vs| ywrrrms rrz:InstructionTranslatorBase.create_resume.. s!TQBS=S!!Trorr r NTr8rz&variables should not be NULL in < 3.12z?expected self.current_instruction.offset is not None to be truec3HK|]}|jjywr)r.rrrs rrz:InstructionTranslatorBase.create_resume..A s.E s:A!++-:rorig_graphmodulecyrrrrrrz9InstructionTranslatorBase.create_resume..Q rrresumesr)5rIstack_ctx_argsstack_ctx_idxes_origrrnr append_outputr'r r r+rrr(locals_ctx_argsrrrr0r.rr1rr rvr6rlocals_null_keysrr#rerZrstack_null_idxesrrMlookuprrr r(r2 get_contextrweakrefrefr(install_resume_function_globalrzradd_resume_functionr[r)rr resume_instr resume_codesris_leafhandle_inactive_ctxjrj_origrvr resume_name all_argnamesrJ argnames_nullrA stack_lennew_codeorig_graphmodule_maybernrs` @@rrz'InstructionTranslatorBase.create_resume sGT "%d&9&94;T;T"U A2DJJv4FG  !12$$R(  $Q,,S1//1,,Q/  +>:     // a2D4H4H4NO  !12$$R(  $Q,,S1//1,,T^^d>O>OPT>U-UV  +>:   ( K (%%$%MNN%,,K,{/A/A.B CD %d&7&7EE !--!L !$D$9$9 : S SSH!!T\!TTM   "$((-++-"$     &(,,T^^d>O>OPS>T-TU//1%Q     &y1&|XG!^ )tD  T..3356H!$"7"78M   g %=!Q&$%MNN Oc$*?*?&@@  # # * * 2 Q $:#@#@ KK KK  $ $ + +    <4+;+;< <    :)9)9: :  $%% & $&& ' $'' ( , -- -!$ *" !9!9$++!F!J!J  " "  " -EL[[&FL $ $X ./A B 22 4>>  << # LL , ,$..4k  H,,-2-$$rcJ|jy t|j|j}t |j |z }|j |}t |tr|jtjusy|jj}|jr|jjn |j}|yt!||}|j"j%d|}t|t'||j |<y#t$rYywxYw)aReplace warnings.warn on the symbolic stack with a wrapper that preserves the leaf frame's source location for warning dedup. When nested graph breaks inline a warnings.warn call into the root frame's bytecode, the root frame's line numbers defeat Python's per-location warning dedup. This replaces the SkipFunctionVariable for warnings.warn on the symbolic stack before compile_subgraph, so the codegen naturally reconstructs the wrapper via LOAD_GLOBAL. N__warnings_warn_wrapperr)rAr,rrrrrVrzr _warningsrrrrrrrr(install_globalrR) rrr! callable_idx callable_var leaf_filename leaf_linenor wrapper_names rrCz?InstructionTranslatorBase._maybe_replace_warnings_warn_on_stacke s 88   +DKKBE4::. zz,/ |%9 :""inn4  // /3~~dnn++4CSCS   -m[I{{112KWU #7 L6$  < %   s D D"!D"c d|_t|jj}g}g}g}|}d}|i||ur|} n |j} | j dk7r3|j ||j ||j | |j}|dz }|it|jt|djz } |s| dk\s td|jt| dzt| dzD]} |jt!d|jt!d|j#S|d|ur)|jt!d| d} | |d_n|jt| t| dz D]} |jt!d|jt!dd ||dj$} ||dxj$dz c_|dj't)|jgt+d|j-|d|j/t1| | d g} |D]F}| j3t5|j-||j/gtdH| j3t!dt!dt| g|j| |jgtdt7j8| tdg}g}t;|D]L\}}|j=||||||||||ud \}}|j ||j |N|j?||||jt!d|j#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. Nrrrz*expected current_num_stack >= 1 to be truerrr r T) rr3r(rrrrrrrr}rr r+rXrzr(rjrrFrr&rrr#rr'rEdeepcopyrkrr)rrrrtxesidxes resume_instsrrrcurrent_num_stackrstack_insert_idx filter_instsr resume_namesrg resume_coders rrz/InstructionTranslatorBase.create_call_resume_at s6$( t{{** +13*, 37 ~" $55 !!^3 F# S!##K0]]F 1HC   Oc %a ( 9 9/    &*$%QRR   [):Q)>? @,q01 @  !3I!>? @   /? @&&( ( 7d?   / BST U 5F %a ( 2   [):; <,q01 @  !3I!>? @   / !D E8qBLL  %eAh / 9 9Q > 9 GLL* +  Q $$U1X. '')   %%57GN     C   "$((-++-!^    "9-"rctjdk\rJ|jj}|r2|jr%|j |jdj uryt d|jDxr{|j xrl|jxs |j xrO|j xr@|j xr1|j xr"|jjjduS)Nr6rFc3<K|]}|jywr)r2rrs rrzIInstructionTranslatorBase.should_compile_partial_graph..s:A :r)rZrrrFr r.rr+rrrr*!skip_one_hop_torch_function_depthr(current_tracerr)rrs rrz6InstructionTranslatorBase.should_compile_partial_graphs   w &,,::E$$ D?' KH#&%(2!29-889  sA##4BBc2|j|ty)Nr)rrrs rBUILD_TUPLE_UNPACKz,InstructionTranslatorBase.BUILD_TUPLE_UNPACK+s t7rc t||ry|j|jdz}tt |ddd|ddd}|j t j||y)Nrr)r4rHrwrrIrFrgrx)rrrds r BUILD_MAPz#InstructionTranslatorBase.BUILD_MAP0sa 0t <  $++/* U3Q3Zqt!t- . /''a01rc~|j|j}|Dcgc].}tj|tj ||gi0}}i}|D]8}t |ts td|j|j:|jtj||ycc}w)Nz4expected isinstance(x, ConstDictVariable) to be true) rHrwrgrxrrGrVrsrupdaterrF)rrrrbrs rBUILD_MAP_UNPACKz*InstructionTranslatorBase.BUILD_MAP_UNPACK8s $++&   ! !$ - ; ;D1#r J  "$ #Aa!23$J MM!'' "  #  ! !   s3B:c |j}|j|j}t|ts t d|j s t dt||}t|t|k7r t d|jtj|tt||y)N3expected isinstance(keys, TupleVariable) to be truez-expected keys.is_python_constant() to be truez,expected len(keys) == len(values) to be true)rrHrwrVrrrrcrrFrgrxrrI)rrrers rBUILD_CONST_KEY_MAPz-InstructionTranslatorBase.BUILD_CONST_KEY_MAPOsxxz4;;'$ . !VW W&&( !PQ QtT* t9F # !OP P  ! !Sv&'  rc@|jd\}}|jdkDs td|j td|j|j j }t |ts td|j|d||fiy)Nrr#expected inst.argval > 0 to be truer>6expected isinstance(obj, ConstDictVariable) to be truer) rHrwrrArrrVrsr)rrrrr=s rMAP_ADDz!InstructionTranslatorBase.MAP_ADDbsyy|1 a !FG G 88  !KL Ljj$((#++-#01 H  maVR8rcP|j}|jdkDs td|j td|j|j }t |t s td|js td|j|d|giy)Nrrr>0expected isinstance(obj, SetVariable) to be true$expected obj.is_mutable() to be truer rrwrrArrVr is_mutablerrrrr=s rSET_ADDz!InstructionTranslatorBase.SET_ADDos HHJ a !FG G 88  !KL Ljj$((##{+ !ST T~~ !GH H eaS"-rcP|j}|jdkDs td|j td|j|j }t |t s td|js td|j|d|giy)Nrrr>rrrrrs r SET_UPDATEz$InstructionTranslatorBase.SET_UPDATE|s HHJ a !FG G 88  !KL Ljj$((##{+ !ST T~~ !GH H hR0rc|j}|jdkDs td|j td|j|j j }t |ts td|js td|jjj||jj|y)Nrrr>1expected isinstance(obj, ListVariable) to be truer)rrwrrArrrVrrr(r+mutationrrrs rr z%InstructionTranslatorBase.LIST_APPENDs HHJ a !FG G 88  !KL Ljj$((#++-#|, !TU U~~ !GH H   ))#. rc v|j}tjdkr|j}|j}tjdk\rKt |j ds t dtj||j j}d}d}d}d}tjdkrV|T|dzr|j}|dzr|j}|dzr|j}|dzr|j}t||j|||} |r~t|ts t d |j} tt!t#| ddd| dddd t% } | j'|j)d | |j+| y)Nr6 co_qualnamez6expected hasattr(code.value, "co_qualname") to be truerrrrz:expected isinstance(annotations, TupleVariable) to be trueTstrictrr)rArZrrr5rrrgrxrryrzrVrrrsrrIrf get_dict_vtsetitemrF) rrrfn_namerdefaultsclosurer kwdefaultsrRranns r MAKE_FUNCTIONz'InstructionTranslatorBase.MAKE_FUNCTIONs   g %hhjGxxz   w &4::}5$L&++D$**2H2HIG    g % 4<"hhjG4<"&((*K4?.0C NN4 ( (!3  " rc ^|j}t||}t||jkr&t |d|jdt|dt||jkDrt |d|jdt |D]}|j |y)Nz¬ enough values to unpack (expected , got rz$too many values to unpack (expected )rrcrrwr:rrF)rrrrirgs rrz)InstructionTranslatorBase.UNPACK_SEQUENCEshhjdC( s8dkk ! 8 VCPSH:UVW  s8dkk ! 6t{{m1E # A IIaL rc d|jcxkrdkstdtd|jdz}|jdz }|j}t||x}rt ||}t |||zkrt |d||zdt |d|d|}||t ||z }|t ||z d} t| D]} |j| |jt|t t|D]} |j| ytd t||d gtj y) Nriz.expected 0 <= inst.argval <= 0xFFFF to be truerz/not enough values to unpack (expected at least rrrz%Failed to unpack object for UNPACK_EXz; cannot be unpacked into a list for the UNPACK_EX bytecode.r)rwrrrrcrr:rrFrrfr=rrr) rrrsuffixriteratorr? vals_prefix vals_list vals_suffixitems r UNPACK_EXz#InstructionTranslatorBase.UNPACK_EXslT[[*F* !QR R+ !QR Rt#!hhj&tS1 18 1"42D4y6F?*!EfvoEVV\]`ae]f\gghiw-KVc$i&&89Is4y6134K -  $ IIl9|jrtddddgyy)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)rr=rs rgraph_break_on_leaf_functionz6InstructionTranslatorBase.graph_break_on_leaf_functions0  $ $ =6^   %rcF|jdk(r|j|yy)NGRAPH_BREAK_IF_LEAF)rwrrs rrzInstructionTranslatorBase.NOP s" ;;/ /  - -d 3 0rc$|jyrrrs rrz!InstructionTranslatorBase.POP_TOP   rc|j}|j}|j||j|yrrrFrrrrs rROT_TWOz!InstructionTranslatorBase.ROT_TWOs. HHJ HHJ !  ! rc|j}|j}|j}|j||j||j|yrr)rrrrcs r ROT_THREEz#InstructionTranslatorBase.ROT_THREEsD HHJ HHJ HHJ !  !  ! rc |j}|j}|j}|j}|j||j||j||j|yrr)rrrrr rs rROT_FOURz"InstructionTranslatorBase.ROT_FOUR sZ HHJ HHJ HHJ HHJ !  !  !  ! rch|j}|j||j|yrr)rrrs rrz!InstructionTranslatorBase.DUP_TOP*s# HHJ !  ! rc|j}|j}|j||j||j||j|yrrr s r DUP_TOP_TWOz%InstructionTranslatorBase.DUP_TOP_TWO/sD HHJ HHJ !  !  !  ! rc,|dk(r,tj|tj||giS|dk(r,tj|tj||giS|dk(r,tj|t j||giS|S)Nrrr)rgrxrrGrascii)rrflags r_convert_valuez(InstructionTranslatorBase._convert_value7s 19"((s3AA$QST T QY"((t4BB4%RTU U QY"((u5CCD5'SUV V rc|j}t|tr@ddlm}m}|j ||||j|}|j|y|j||dz}tj|d|jzdz}|jttj ||giy)Nr)LazySymNodeFormatStringr~)rrrz{:})rrVrtorch._dynamo.variables.lazyrr~ryrrFrrgrxrrGrkrformat)rfmt_specrrrr~fmt_vars r _format_valuez'InstructionTranslatorBase._format_value@s  e_ -  /'..'x8RVE IIe  ##E54<8!'' $4466<  ?3::6%8H"Mrc|j}| td|dzdk(r|j}ntj|d}|j ||S)N%expected flags is not None to be truerr)rArrrgrxr)rrrrs r FORMAT_VALUEz&InstructionTranslatorBase.FORMAT_VALUEVsX = !HI I DLT !xxzH&,,T26H!!(E22rc ng}g}i}|j td|j|jD]:}|jr#|j d|j |7t |t jr|j |j|j|jt|jt|jjzr2tdd|d|d|jdgtj |j#|jtd t%|d gtj =|j't jj)d j+|||y) Nr>z{}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)rArrHrrrVrStringFormatVariable format_stringrsym_argsrre sym_kwargsr=rrrrrFryr)rrformat_string_partsrrparts r BUILD_STRINGz&InstructionTranslatorBase.BUILD_STRING`s{)+&(-/ 88  !KL LIIdhh' D&&(#**40 D!D)"@"@A#**4+=+=> DMM*v{{}%DOO,@,@,B(CC! ;"78K7LJW]V^^qrvsBsBrC!D$W= 1 < <=   doo.5I n9-889 ! ,  * * 1 1+,dF  rc|jdk(s|jdk(s td|jdk(rdnd}|jt|||j diy)Nrr8expected inst.argval == 0 or inst.argval == 1 to be trueiszis notr)rwrrFrrH)rrrws rIS_OPzInstructionTranslatorBase.IS_OPs` q DKK1$4 J )x %f-dDIIaL"EFrc|jdk(s|jdk(s td|jd\}}|j}|jt ||||dk(r|j |yy)Nrrr+r)rwrrHrFr UNARY_NOT)rrleftrightrs r CONTAINS_OPz%InstructionTranslatorBase.CONTAINS_OPss q DKK1$4 J iil e [[ "456 7 NN4  rcP|j}|jdkDs td|j td|j|j }t |t s td|js td|j|d|giy)Nrrr>rrr) rrwrrArrVrrrrs rrz%InstructionTranslatorBase.LIST_EXTENDs HHJ a !FG G 88  !KL Ljj$((##|, !TU U~~ !GH H hR0rc|jtj|tj ||j giyr)rFrgrxr6rGrrs r LIST_TO_TUPLEz'InstructionTranslatorBase.LIST_TO_TUPLEs6  ! !$ . < rrr) rrwrrArrrVrsrrrs r DICT_MERGEz$InstructionTranslatorBase.DICT_MERGEs HHJ a !FG G 88  !KL Ljj$((#++-#01 H ~~ !GH H hR0rc$|jyrrrs r GEN_STARTz#InstructionTranslatorBase.GEN_STARTrrc |jd}|jr=|jtj|t |j y|j|j|dgiy)Nrr)rrrFrgrxrrrrs rGET_LENz!InstructionTranslatorBase.GET_LENs]jjn  ! ! # IIo++D#c6L6L6N2OP Q IIcoodIr2> ?rc|jd}|j|jtj|t |giy)zr If STACK[-1] is an instance of collections.abc.Mapping, push True. Otherwise, push False rN)rrFrrgrxrGrs r MATCH_MAPPINGz'InstructionTranslatorBase.MATCH_MAPPINGsC jjn  , ,%%dO<  rc|jd}|j|jtj|t |giyNr)rrFrrgrxrJrs rMATCH_SEQUENCEz(InstructionTranslatorBase.MATCH_SEQUENCEsBjjn  , ,%%d,?@  rc |jd\}}}tj||j}|j |j tj|t ||||gitjdkrD|jd}|j tj|t|t yy)Nrr6r) rHrgrxrArFrrHrZrrr`rm)rrsubjectrnamesrArs r MATCH_CLASSz%InstructionTranslatorBase.MATCH_CLASSs"iile##D$((3  , ,%%d,<=#sE*     g %**R.C IIo++DfSBR6S2ST U &rc |jd}|jd}t|ts td|j |j t j|t||gitjdkrD|jd}|j t j|t|t yy)Nrrrr6) rrVrrrFrrgrxrIrZrr`rm)rrrer=rs r MATCH_KEYSz$InstructionTranslatorBase.MATCH_KEYSszz"~jjn$ . !VW W  , ,%%dO)rAr_binary_op_lookuprs r BINARY_OPz#InstructionTranslatorBase.BINARY_OPRs.xx$%OPP$TXX.tT: :rcyrrrs rr;z!InstructionTranslatorBase.PRECALLW rcH|j td|jd|j}t|ts td|D]}t|t rtd|j tdtj||_y)Nr> co_constsz/expected isinstance(kw_names, tuple) to be truez)expected isinstance(name, str) to be truez)expected self.kw_names is None to be trueru) rArrrVr6rrDrmry)rrrDrs rr<z"InstructionTranslatorBase.KW_NAMESZs 88  !KL L$$[1$((;(E* !RS S RDdC($%PQQ R == $ !LM M(//h? rc6|jtyr)rFrrs rrz#InstructionTranslatorBase.PUSH_NULLgs ,.!rcn|rutjdk\s td|j}t |t s td|j s td|j}n$|jr|jjnd}|j td|j|jdz}tjdk\r!|d}t |d trgn|d g}n&t |dtr|d }g}n |d}|d g}|rX||dt| z}|t| d}tt||}t|t|k7rtd ||ddz}i} |j!|||d|_y#d|_wxYw) Nrz/expected sys.version_info >= (3, 13) to be truez7expected isinstance(kw_names, TupleVariable) to be truez1expected kw_names.is_python_constant() to be truerr>rrrz0expected len(kwargs) == len(kw_names) to be true)rZrrrrVrrrrDrrArHrrrrIrG) rrcall_kwrDcontentsrRrrKrs r_callzInstructionTranslatorBase._calljs $$/$%VWWxxzHh 6$M..0$G 224H.2mmt}}**H 88  !KL L99TXX\*   w &!B#HQK>2Xa[MD(1+|4a[a[  } (1H ~66D"CM>#34K#h 45F6{c(m+$%WXX(12,&DF !   r4 0 DMDDMs F++ F4zTEncountered graph break when attempting to trace CALL: a function call, e.g. f(x, y)c&|j|yrr_rs rr:zInstructionTranslatorBase.CALLs 4rc|j td|j|j|j yrT)rArrFrrs rCOPYzInstructionTranslatorBase.COPYs3 88  !KL L $**dhhY'(rc|j td|j|j |jdc|jd<|j|j <y)Nr>r)rArrrs rSWAPzInstructionTranslatorBase.SWAPsS 88  !KL L04 DHH90EtzzRT~- 2 DHH9-rcyrrrs rCACHEzInstructionTranslatorBase.CACHErXrc&|j|yrrrs r BEFORE_WITHz%InstructionTranslatorBase.BEFORE_WITHrrc t|tr+|js|jj |t j dk\r|jr>|jr/|jj|jdjurd}nN|jj td|jjj}n |j}|rt|tstjr;|jj t||t!|j"|n9|jj t||t!|j"|j%|S)Nr6rzCexpected self.next_instruction.exn_tab_entry is not None to be true)rVrosupports_graph_breaksr*rrZrrFr r.rrrLrrr-rrenter)rrvrr.s r enter_ctxz#InstructionTranslatorBase.enter_ctxs4 s: ;--/  0 0 7 7 <   w & !!$$%%,,D4D4DR4H4O4OO((66>(]..<<CC[[F $ 56&:T:T  ''#D&#djj/3G  ''fc$**o(VWyyrcPtdd|d|jdgdy)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)r=r)rvs runsupported_ctx_graph_breakz5InstructionTranslatorBase.unsupported_ctx_graph_breaks31GuM?@T@T@V?WWij rc@|j}t|ttfs|j |t|ttfs t d|j t||j|j |j||y)N`expected isinstance( ctx, (ContextWrappingVariable, GenericContextWrappingVariable) ) to be true) rrVrnrororrFrqr.rm)rrrvs rrz.InstructionTranslatorBase.setup_or_before_withshhj )+IJ   , ,S 1 )+IJ !r  *3 <= $..d+,rch|js td|jj|y)Nz+expected self.accept_prefix_inst to be true)rrrrrs rrQz,InstructionTranslatorBase.append_prefix_inst s+&& !NO O   &rc@tjdk\rz|jsnt|j|j t s td|jjj|j|j <y|j|y)Nr8zOexpected isinstance(self.symbolic_locals[inst.argval], NullVariable) to be true) rZrrrVrrwrrr(r+track_cell_newrQrs r MAKE_CELLz#InstructionTranslatorBase.MAKE_CELLs   w &t/F/Fd224;;?N$e ((779   -  # #D )rc&|j|yrrQrs rCOPY_FREE_VARSz(InstructionTranslatorBase.COPY_FREE_VARS  %rc&|j|yrrwrs rRETURN_GENERATORz*InstructionTranslatorBase.RETURN_GENERATOR#ryrc2tjdk\r|jn|jdtjdk\rO|j|}||j vr1|j j ||xjdzc_yyy)Nrrr8r)rZrrrHr_comprehension_end_for_ipsdiscard_comprehension_depth)rr current_ips rEND_FORz!InstructionTranslatorBase.END_FOR*s   w & HHJ IIaL   w &d+JT<<<//77 C))Q.)= 'rct|jj|jdtr6t d|jd|jgt j|j|y)Nz)LOAD_FAST_CHECK on uninitialized variablez/Attempted to load uninitialized local variable r) r`rrrwrr=rrrLrs rLOAD_FAST_CHECKz)InstructionTranslatorBase.LOAD_FAST_CHECK7s` $&&**4;;=| L C Mdkk][5)445   trc|j|jvr|jtn|j |t|j|j<yr)rwrrFrrLrs rLOAD_FAST_AND_CLEARz-InstructionTranslatorBase.LOAD_FAST_AND_CLEARAsD ;;d22 2 IIln % NN4 ,8NT[[)rc|jtj|d|j t d|jdzr|j |y|j |jy)Nrr=r>r)r@rrrArrOrrwrs rLOAD_SUPER_ATTRz)InstructionTranslatorBase.LOAD_SUPER_ATTRHs\ ;..tA>? 88  !KL L 88a<   T " OODKK (rc>|jdk(r|j|y|jdk(r|j|y|jdk(r5t||j }|j t |y|jdk(rN|j j}tjt|}|j |ytdd|jd|jdgtj y) Nrrrz Missing CALL_INTRINSIC_1 handlerzCALL_INTRINSIC_1 operand: z,No handler implemented for CALL_INTRINSIC_1 instruction.r)rwr8UNARY_POSITIVErcrrFrrrTypingVariabler r=rrR)rrrrtvs rCALL_INTRINSIC_1z*InstructionTranslatorBase.CALL_INTRINSIC_1Qs ;;!   $ $T * [[A     % [[A #D$((*5E IImE* + [[A  --/A))'!*5B IIbM :4T[[MBJ4;;-Wde6)556  rc|j}|j}|jdk(rVt|ts t d|j |dt jd|gi|j|ytdd|jd|jdgtj y) Nrz>expected isinstance(arg1, BaseUserFunctionVariable) to be truer__type_params__z Missing CALL_INTRINSIC_2 handlerzCALL_INTRINSIC_2 operand: z,No handler implemented for CALL_INTRINSIC_2 rr) rrwrVrtrrrmryrFr=rrR)rrarg2arg1s rCALL_INTRINSIC_2z*InstructionTranslatorBase.CALL_INTRINSIC_2isxxzxxz ;;! d$<=$T   !(():;TB   IIdO :4T[[MBJ4;;-Wde6)556  rcf|j}|j|j|yrrrs rEND_SENDz"InstructionTranslatorBase.END_SENDs!hhj   #rzpEncountered graph break when attempting to trace CALL_KW: a function call with keyword arguments, e.g. f(x=True)c*|j|dy)NT)r]rars rCALL_KWz!InstructionTranslatorBase.CALL_KWs 4 &rcJ|jjdvr tdy)N)POP_JUMP_IF_TRUEPOP_JUMP_IF_FALSEr/zmexpected self.next_instruction.opname in ( "POP_JUMP_IF_TRUE", "POP_JUMP_IF_FALSE", "UNARY_NOT", ) to be true)rrrrs rrz!InstructionTranslatorBase.TO_BOOLs4  ' '0  !   rc  |j}| td|j}t|ts td|j}|dzrpt j dk\s td|j|tj|dgi}|j|dtjd|gin|d zr||_ n|d zrt|ts td |j}t!t#t%|ddd |ddd d t'}|j)|j+d|n|d zr||_n |dzr||_|j1|y)Nr z>expected isinstance(fn, NestedUserFunctionVariable) to be truerz/expected sys.version_info >= (3, 14) to be truerrrrrz3expected isinstance(attr, TupleVariable) to be truerTrr)rArrrVryrZrrGrgrxrrmryrrrrsrrIrfrrrrrF)rrrrRrXrrs rSET_FUNCTION_ATTRIBUTEz0InstructionTranslatorBase.SET_FUNCTION_ATTRIBUTEsu = !HI I XXZ"89 P xxz 4<$$/$%VWW%%d_-B-B4-K,LbQD NN!(():;TB   T\BJ T\dM2$I JJE#SssU14a4[>?.0C NN4 ( (!3 T\ BM T\BK " rc|j td|j|j|j |jyrT)rArrFrrrs r CONVERT_VALUEz'InstructionTranslatorBase.CONVERT_VALUEs; 88  !KL L $%%dhhj$((;rcD|j|jdyr)rrrs rFORMAT_WITH_SPECz*InstructionTranslatorBase.FORMAT_WITH_SPECs 488:q)rcl|jtjdk\r|jyy)Nr)rrZrrs rPOP_ITERz"InstructionTranslatorBase.POP_ITERs'    w & HHJ 'r) __enter____exit__ __aenter__ __aexit__czt|jts td|j|j}|dvr|j }t|t tfs|j|t|t tfs td|dk(r,|jt||j|y|jt|d|j|y|j||j }|j||j|y)Nz*expected LOAD_SPECIAL arg to be set to int)rrrqr)rVrArr_load_special_namesrrnrororFrprrqr)rrrXrvr=s r LOAD_SPECIALz&InstructionTranslatorBase.LOAD_SPECIALs $((C( !MN N''1 , ,((*C-/MN005-/MN%v{" 3C89t$ 23=>t$ OOD !((*C IIcN NN4 rcb|jtj||jyr)rFrgrxrwrs rLOAD_SMALL_INTz(InstructionTranslatorBase.LOAD_SMALL_INT s /''dkk:;rrrct|jts td|j t j ||j|jy)Nz2expected LOAD_COMMON_CONSTANT arg to be set to int)rVrArrrFrgrx_common_constantsrs rLOAD_COMMON_CONSTANTz.InstructionTranslatorBase.LOAD_COMMON_CONSTANT"sD$((C( !UV V /''d.D.DTXX.NOPrcP|jjdkDr d|_yy)NrcyNTrrrrrz>InstructionTranslatorBase.is_non_empty_graph..*rvrTF)r( count_callsrrs rrz,InstructionTranslatorBase.is_non_empty_graph's% ;; " " $q (&2D #rc |g}djtj|jgt t |zS)Nr)r traceback format_listrrr)radditional_stack_framess rformat_frame_summaryz.InstructionTranslatorBase.format_frame_summary.sN # *&( #ww  ! !##%&h7N.O)PP   rc 4|jj}i}tjdk\r ||j|d<|j |d<t jt|jdd|jt|jddfddi|S) Nr6colno end_colnor r lookup_lineF) rrrZrr:r;r FrameSummaryrrr)rrrs rrz'InstructionTranslatorBase.frame_summary9s,,66 !#   w &9+@'22F7O"+":":F; %% DKK < KK DKKK 8      rct|jdd}tjd}|j |duS)Nrrz.*torch/nn/modules.*)rrrecompilematch)rrnn_modules_patterns ris_co_filename_from_nn_modulesz8InstructionTranslatorBase.is_co_filename_from_nn_modulesHs:4;; {CZZ(?@!''1==rc|jj|tj|}t t |j tj|Sr) r(install_global_by_idrrrBrSrrA WEAKREF_ALIVE)rrr global_names rstore_global_weakref_by_idz4InstructionTranslatorBase.store_global_weakref_by_idMsJkk66vw{{5?QR   , 7 7 8R8R S rcB|jjjSr)r(tracing_context fake_moders rrz#InstructionTranslatorBase.fake_modeTs{{**444rc#bK|j}||_ d||_y#||_wxYww)zx Strict mode is enabled on a per-VariableTracker level depending on the return value of check_fn(node). N)r)rcheck_fnpriors rstrict_translation_modez1InstructionTranslatorBase.strict_translation_modeXs3%% ( * $)D !ED !s/#/ ,/c*|j td|jdkDs td|jj|jj |j |jdz |j|jdz S)Nrr0expected self.instruction_pointer > 0 to be truer)rrr$rrrrrvrs rr)z#InstructionTranslatorBase.speculatefs  # # + J ((1, !ST T##(( KK # # KK  $ $q (   d66: ;   rc ||dkr||fS||fSrr)rrrfallback_linenos r_make_frame_locz)InstructionTranslatorBase._make_frame_locts% >VaZo. .&!!rcdg}tjrs|j}|e|j|jj |j |jj}|j||j}|e|j|j|t|Sr) rrrrrrrrrreverser6)r frame_locframe_loc_chain_list current_txparent_frame_locs r_get_frame_loc_chainz.InstructionTranslatorBase._get_frame_loc_chain{s79  % %;?;;J(#'#7#7%%11%%%%44$ %++,<='.. ( $$&##I.)**rct}g}|jD]Z}|j}|||vr|j||j d|d|j j \|syddj|zS)zLFormat bytecode source locations for stack values involved in a graph break.z z originated from: rz#Stack variable source attribution: r)rrr<rrrrr)rseenpartsvtr<s r _format_stack_source_attributionz:InstructionTranslatorBase._format_stack_source_attributions$'E** B 00O&$& HH_ % LLRF-o.D.D.F.M.M.O-PQ  5 %8HHHrc6 |jryt|dd}|(tjjj } t jrR|jF|j|jj|j|jj}n-|j|dj|djd}|j!|}d}t j"r/t%}dj't)j*|}nt%|z}t-|}dj't)j*|} | t/||}|j1} d|dd|d d |g} | r| j3d| g| j3dd gd j'| d z t j"r |d | dz n t5| z tj6j9dd fdt;|t<r |j>n tA|} tBjEtFjHrptJsjtMjN| |frSt j"r& dz d j'|jPd zz tBjS d|_ytBjSd|d|d |d|_y#t$r|d|df}YAwxYw)Nr'rrrrrzGraph break in user code at rrzGraph Break Reason: zUser code traceback:rzQ ========== 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. artifactc dddS)Ndynamo_graph_break_reasonstring)rencodingrrrrrz;InstructionTranslatorBase.log_graph_break..s3$!rc6dtjS)Nr)r format_exc)user_stack_tracesrrz;InstructionTranslatorBase.log_graph_break..s"2!32i6J6J6L5MNr) metadata_fn payload_fnz4 Most recent bytecode instructions traced (max 20): zmGraph break (user stack suppressed due to duplicate graph break) in user code at %s:%s Graph Break Reason: %sT)*loggedrrrrrrrrrrrrrr IndexErrorrrr9rrrr7r5rrr_loggingtrace_structuredrVr>rr]graph_break_log isEnabledForrDEBUGexplainr_rrr)rrrr user_stackrframe_loc_chainstack_above_dynamo_formattedstack_above_dynamouser_stack_formattedstack_source_attributionuser_stack_trace_partsrrs @rrz)InstructionTranslatorBase.log_graph_breaks :: S,5  55CCEJ ))dkk.E 00KK++KKKK.. !00rN++rN)) 33I>')$ >>!7!9 +-77%%&89, (01J>J/ ;J!wwy'<'> /01e'()LL   $8 9 9  '' O ( ",C!=#++49  ( ( 7/33Wo4NO ~~ L !DIId.H.H$ID$PP  ! !     ! !A! !    k ]+-.I sBLLLc^tddt|dgtj|dy)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)rrrrr$r%)r=r8rr-)rrs rrz0InstructionTranslatorBase.raise_loop_graph_breaks; )%&7&=%>?hD%CCD rcht|||_||_||_||_||_| |_| |_d|_ g|_ d|_ d|_ td|_d|_g|_g|_d|_d|_d|_d|_g|_||_t1d|_d|_t7|_t;d|_i|_||_ ||ntC|j@|_"||_#||_$||_%||_&| |_'||_(|$tRjTrtW| |||_,nd|_,i|_-i|_.| |_/d |_0d |_1d |_2d|_3d|_4d|_5d|_6d |_7g|_8||_9d d l:m;}m<}m=}m>}||z|z}t~jd kr||z}| j|zr|jtd| |_Dd |_Edgt| jz|_Htjtj|_Mtjtj|_Otj| j|y) NrrTr)maxlenc,tjdSr)rrrrrrz4InstructionTranslatorBase.__init__..Zs  2r)rrrFr)CO_ASYNC_GENERATOR CO_COROUTINE CO_GENERATORCO_ITERABLE_COROUTINEr6)SrUrVr$distributed_stater(rrrrrrrrr(rr(r r*rrrDrrrrrrrr}rrrrvrrrGrzr|rrrrreplay_record_enabledrLrnn_module_stack num_callsexportr+rrrrrrrrrresume_executionrrrrrZrco_flagsrFrkrrrrZrvrrrrrrrr lazycacher)rr(rvrGrzr|rrrrrrr rr$rrrrrrrrr push_typesr\s rrVz"InstructionTranslatorBase.__init__"s0 .!2 . 0-J*%:"-1),. #$ #5e#< (,%UW,67.  "&(%*"%5"$%!47E' 2 3 $57!0<*G Dr@rGrLrQrSrOrVrrZr]rar_ staticmethodrhrrCrrrr r rrrrr rrrrBUILD_TUPLE_UNPACK_WITH_CALLrrBUILD_MAP_UNPACK_WITH_CALLrrrrr rrrrrrr r rrrrrr!r)r-r2rr5r8r: DICT_UPDATEr<r>r@rCrGrIrLrOrSposrnegUNARY_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_ORrRrVr;r<rr_r:rcrerJUMP_BACKWARD_NO_INTERRUPTPOP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUEPOP_JUMP_FORWARD_IF_FALSEPOP_JUMP_BACKWARD_IF_FALSErgrirmrorrQrurxr{rrrrrrrrrrrrrLOAD_FAST_BORROWrrrrrrrr6rrrrrrrrrrrr contextlibcontextmanagerrr)rrrrrrVr^r_s@rrrCsQ  //00#==.."CC  ##$$""&& K%%####00  ++>> ,,! EE ""%%.$L00 B1'  8 8$8+ 8  88 4 $ 4$ 4+ 4  4$+0  $$+  $(  *n Wrh 7"- +b ;;IV2 M=^0 ;!+F V 2') V/ L *J,JJ !E(##2 2:;|$% 44.> 4LM$X]]E:#HNNE:' t<&x~~t<U U (U #J (8 "8 158 8 t(T"C..,)\D'L<:$0RhL uP P T ) )  @; @;D A -  -"G " % A   8&) @}% }%!}%" }% + }%  }%}%"}% $}%~# Jh%h%$=h%  h%TJ?*J?:CJ?IRJ? J?J?X ( ~= =84"4)84 4((16 @L@ 8$6 2 *"2 & 9 . 1 5n : N  4   N,3  DG ! 1 %4 1K@   V V$CDhll+Nhll+N'IHOO,LHLL)Lx||,O%hoo6"8#4#45!("2"23X\\*M -(,,'Jx||,O. ux "MX__-MX__-M(--(J&I(,,'JX]]+M .&x'7'78#H$6$67"8#4#45hmm,N /8==)K .h../Nh../N8==)K8==)K(,,'J X 7" ;   @"7!r i ) V M!%+HNNEB ,X^^U C ,X]]E B!-hmmU!C (& E&&  &P  -$' *&& /;)02 A '  ' .`= ?*!I!@<            Q ;?  '7      > 55 *9 *  * *  ""%/"BE" "+(+ $+(I&p!pp7 p  pd    #:      @15)-15-M;M;(M;! M; " M; # M;"M;4M;5M;(BM; 3M;M;M;M;(M; %!M;"3#M;&.'M;(')M;,/-M;. /M;M;r) metaclassceZdZed dZej d dZ d fd ZddZ ddZ ddZ ddZ ddZ dd Zdd ZxZS)rLc"tjSr)tlsrrrrrz InstructionTranslator.current_txs ~~rc#Kttdd}|t_ d| |t_yttdrt`yy#| |t_wttdrt`wwxYww)Nr)rrmrr5)rrs rset_current_txz$InstructionTranslator.set_current_txsh\40 #  !&l+N, !&l+N,sA4A &A4 'A11A4cttjd|jd|dd|dt!|t || || | | ||||| | ||||||iidd|| d|||||jt|jj5|j5| |_ | |_ |jr|js td i|_t!|j#}d}d}|j$|j&z}|j(t*zr|j,|}|d z }|j(t.zr|j,|}t1j2|j5d d}|j7D]r\}}||vs d}|r)t9|j5|ij7}t;j<|t?|d |||k(||k( |}||j|<t|jj@}|jCD]z}||vrN||}t?|d d }t;j<|||}|jE}|jG||n|jE}||_$||j|<|| tdtK|jM|D]i\}}tO|} t?|d } t;j<|jP||}|jY| ||}||_$||j|<kt[|d|_.t_|_0| r.tTj:jc|j|_ddddddy#tR$rtUjV}YwxYw#1swY5xYw#1swYyxYw)Nztorchdynamo start tracing rrrr) local_scoperrtorch_function_mode_stackr+rr)r(rvrGrzr|rrrrrrrr rr$rrrz4Export without one graph - something has gone wrong.rdynamismT)is_inputrs is_varargsis_varkwr)rtis_derefed_cell_contentsz'expected closure is not None to be true)rwF) skip_next)2r"rINFOrrUrVrE_throw_if_in_functorchrr(rror+r rrrr co_argcountco_kwonlyargcountr ru co_varnamesrvr2rrr frozensetr~ryrUr+rrtrqrrrIrrT cell_contentsrrDeletedVariabletrack_cell_existingrrrr realize_all)"rrvrrGrzr|rrrr compiler_fnr+r export_constraints frame_stater$rrrr varargs_name varkw_name _vararg_idxrsrrlocal_dynamismrYr+contents_sourcerQcell_varrP cell_sourcer\s" rrVzInstructionTranslator.__init__s5(   LL((8,}:U9VVWXdeuXvWw x  "$&*C# &!%*."&+%/A ! F ##%T[[00 1w 43F3F3Hw #,DN DK{{~~(N$&D *-d.D.D.F*G  (,L%)J ,,v/G/GGK+%11+> q /#// < #//7;;JMH'~~/ 5 e00%)N)28<<b3I3O3O3Q)R-44# %)%3(, (<&*j&8   C25D((.! 5( ;;33L % 68#$TNE*'2!%15'O 5H4N4N45L ,::D &(1'D'D'P'P((($kw w w D"?#,#<#<#>L?Ew w w w sQO0C7O (EO ;"N*Abffh.8[PU=U668==&&(D((,v.**.0 !%v%W Y  ?  >V8>rct|tr|j|jSt|tr|j |j Str)rVrUrGrrrRrzrrJ)rrs rget_example_valuez'InstructionTranslator.get_example_valuesE fk *==!2!23 3 fl +>>&"4"45 5rc|jjD]G}t|tst |j t jjsGyy)NTF) rrrVrr.rrnnModule)rrs r$symbolic_locals_contain_module_classz:InstructionTranslator.symbolic_locals_contain_module_classsR%%,,. A!56:$$&<   rct|jrP|jdx}r>t|tr-t t ||t |jd<yyyy)Nrr)rrrVrxrrcrf)rrs r"replace_tos_if_return_is_generatorz8InstructionTranslator.replace_tos_if_return_is_generators\  O 2&&3 <=1c*.0DJJrN>' rc|j|j td|j tdt j d|j|jz t js|jjdk(rw|jsk|js[|jsO|jsC|js7|js+t!j"dt%|j&d|_t)t*j,d|j&j.d|j0dt2j5d |jj7|t9d |j;gd |j0d k(rdnd}t=|dk7r td|dj>r td|jjA|jC||djDt jFrd|jIdgtJdtJ)NrrrrzhNo 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)r&rrrz7expected len(all_stack_locals_metadata) == 1 to be truezEexpected not all_stack_locals_metadata[0].stack_null_idxes to be truez__ret = r)&rrrrr^rrallow_empty_graphsr(rrrr r+rrr SkipFramer8rr"rryrrr!rrrDrrr}rrhrgenerate_pycoderrA)rrrs r_returnzInstructionTranslator._returns1 //1  # # + J     # !ST T'' 0043C3CC )) '')Q.22==?KKNN--33--0=>@  $(   LL' (;(;'9qq %A% ! ( )Q . I  %Q ' 8 8 W  ++  ) )$0I!0L0V0V W%%44W=> ? @   rc&|j|yrrrs rrz"InstructionTranslator.RETURN_VALUE Trc&|j|yrrrs rrz"InstructionTranslator.RETURN_CONSTrr)rrLr)$rvrrrrGrrzrr|rrztuple[Any, ...] | NonerrrrrCrrr+rr rrrrrr$rrrarrrrrrr)rrWrrrr)rrrr#rrhrirorVrzrrrrrrr^r_s@rrLrLs # #v'vv! v " v # v(v$'v"vvvv vv(v %!v"3#v$'%v& 'vp> 9vrrLr6INPLACErBINARY_c#dKtjsdy|jt|_|jj }|jj }|jj |j|j|jtjd} dd}|jj}tj}|r||}||jz } | |jz } t|j |j"|j$| | t'|j(||r|dnd|r|dnd|r|dnd|j*| } |jj-| |jj/| yyy#|jj}tj}|r||}||jz } | |jz } t|j |j"|j$| | t'|j(||r|dnd|r|dnd|r|dnd|j*| } |jj-| |jj/| wwwxYww)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_countrcaller_func_namecaller_filenamecaller_firstlinenois_primitive_call call_stack)rdynamo_profilerprofiler_stater get_current_callerget_call_stackrFrrrtimetime_nsr start_time_ns child_time_nsrrrrrco_coder record_timingadd_child_time) r(rget_inline_depth caller_infor trace_success stack_entry trace_end_nsrrrtimings rprofile_inline_callrsn"  ! !  $ 3 5''::QD2= A45@;q>d"-"?"?% F  ! ! / / 7  ! ! 0 0 <)5=++//1 ||~ [4+-L% (A(AAJ#k&?&??J(%//$--'33%%"4<<0)3>QD2= A45@;q>d"-"?"?% F  ! ! / / 7  ! ! 0 0 <)5=s B5J08F5>C7J05C8J--J0cXeZdZUdZded<ded<e d ddZe ddZe d ddZ dd Z d dfd Z e dd Z dd Zdd Zdfd Z dfd ZddZddZ d dZdfd Zdfd ZxZS)!rz Trace and inline a called methodr<symbolic_resultrrcd}tj|jfd5|j||||}|j cdddS#1swYyxYw)Nc"jdzSrr)rsrrz;InliningInstructionTranslator.inline_call..PsF4G4G!4Krr)rr(rbuild_inline_tracer inline_call_)rrfuncrrrtracers ` rrz)InliningInstructionTranslator.inline_callEsm MM4==?,K ),,*C -F&&( ) ) )s &AA%c |jrtdt|dgt|trt j |jddrat j |jdd}tdt|jd|jd |d d gtj|d }|jrddl m }t|drDt|jdr.|jj|urtj ddSt|dr|jj"nd}d|dg}d|j%vr |d|ddgz }tdd|d|j'd|j%d|j(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_applyrR_originz"allowlist in dynamo known functionrzAvoid calling the function `rQrz: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_selfr=rrVr{rMr get_functionr check_verboseskippedtorch._dynamo.variables.miscrr5rRr SkipResultr get_filenameget_namer)rr`rr fn_qualnamers rcheck_inlineablez.InliningInstructionTranslator.check_inlineable[s ==? 6D k   d0 1g6L6L    !77 ((!!#%?C LD--/05d6G6G6I5JK::=aA?  **4F >> V d#DGGY/GGOO'HH#--?3:$2E$''..2K.{m2>E 1 1 33PQ\P]^hh7  H$[M$--/9JK"//122B6==/S]^i]jk((   rc t|tttfs t d|j d}j j}tjs"|r |jjdx}r|}|Otj|}|jdur t dtjs|r||j<d} |j||}| t d t1j2|j5D]8} t| t6rt#dd|d| dgt,j8:j:dvr\|r-t|dt<j>t<j@fs-t#ddj:d|dj:dgd} tBjDjFjHjKdr&dtMjNjM} tPjRdk\r@jTjVd%fd } tXj[dt]| t^j[d | |j`|r|d}d!}t|tbrU|jesEtg|jitBjjjlr|jo}nd}|rt|tprj js|jt}t|tBjvjxrt{j||tj|jjd"<nt|tro|j}t|tBjvjxr?t{j||tj|jjd"<t|tr t d#tr3t|jjj||$}|St|jjj||$}|S#t $r} t#dd|j%d|j'd|j j(d|D cgc]} | j+ncc} wc} d | d |j%d gt,j.| Yd} ~ ad} ~ wwxYw)&Nz~expected isinstance( func, ( UserFunctionVariable, NestedUserFunctionVariable, LocalGeneratorFunctionVariable, ), ) to be trueFz+expected result.skipped is False to be truez2failed to bind arguments when attempting to inlinezfunc='z' rz ; args = z ; kwargs = z4Argument mismatch when attempting to trace function rUr#z*expected sub_locals is not None to be truez:Encountered unconverted argument when attempting to inlinezfunc: z, arg: zWAn argument to an inlined function was not successfully converted to a VariableTracker.r)rrr __delattr__rzJUnsupported __setitem__/__setattr__/__delitem__/__delattr__ inline attemptz code name: z, args: zAttempted to inline z: where first argument (self) is not a user-defined object.rbytecoderr6cjjj}tj }dj d|d|S)N)rzTRACE inlined call z from r)rrrr]rr)headerrrcur_instr parent_codes rget_trace_call_log_strzQInliningInstructionTranslator.build_inline_tracer..get_trace_call_log_strs[77#--4482+xHOOQ,T\\N&4&QQrrzINLINING %s%s, %sTrtz>expected not isinstance(func, SkipFunctionVariable) to be truerr)KrVr{ryrwrrr(rrdont_skip_tracingpreviously_inlined_functionsrrrr bind_argsrr=rrrrrrrrrrgrrrrrrr _internal log_stateis_artifact_enabledriBytecoderZrrrtrace_call_logrrar!rr~ is_realizedr. peek_typerrrrrrrr-rrr2rforwardrrrrzr/&InliningGeneratorInstructionTranslatorrrr)rrrrrr tracing_ctxprevious_result sub_localsrrArrrarg0 should_checkmodulerrrrs` @@@rrz1InliningInstructionTranslator.build_inline_tracers $*.  !Q  $}}mm33 ''K"-"J"J"N"Nd#) >2CCDIF~~U*$%RSS++ AG 88>  f=J   !MN N!2!2!45 Aa1X$TF'!5 y9-889   <<  Q7766 d%dll^8D6B24<<.@z{   >> # # - - A A* M#,,t,00234F   w &11H --K R R  z2H'I J %tVV]]C 7DL$ 34T=M=M=Odnn.@<<>D#(Ld$45#]]88IF!&%((*>*>?$KK/%001H1HI. &CD!ZZF!&%((*>*>?$KK/%001H1HI. d0 1 P   ;''44,,*C F* 3''44,,*C F o  L  1D4E4E4G3H$--/JhJhIij8<=3??,==>k&SRSWS`S`SbRccde&11   s%R'' U0AU 8T8U  Uc|j}d|_d|_|j}t j }|j r|j|j } |5|jddd|j"|_d|_|j$j&rt)j*dS|j, t/d|j0|j0ur%|j2j5|j2|xj6|j6zc_tjd||j$j8j:j=|t>j@stC|tDr|jFrtI|r}tC|tDrm|jJratC|tDs t/dg}|j,jMs |j,g}tjNtP|| y|j,StI|r_tC|tDs t/d|j,jMs t/d tS|jTtW S|j,S#1swY;xYw#tj$r#}d|d|}tj|d}~wttf$r }d|_d}~wt $rtjd|wxYw#|j"|_d|_wxYw) NFTz!Observed exception DURING INLING z : zFAILED INLINING %sz4expected self.symbolic_result is not None to be truezDONE INLINING %szLexpected isinstance(self, InliningGeneratorInstructionTranslator) to be truerz;expected self.symbolic_result.is_constant_none() to be truer),rrrrrh nullcontextrrr7rrr!rr>r?r%rrr(r)rmryrrrzrrrr traced_coderrrrVris_generator_from_ctx_managerr/generator_exhaustedrsrrrgenerated_itemsrf)rrr strict_ctxrr`rs rrz*InliningInstructionTranslator.inline_call_As&+#(,%{{$002  " "55f6M6MNJ 2   &+/*C*CF ',1F ) ;; " "#**40 0    ' !WX X >>V-- -  # # * *4+@+@ A((D,J,JJ( $d+ ##//66t<  4 4 tC D22T"t%KL,,!$(NO(f ++<<> 001D,,]DtL+++D!!$(NO(f++<<>(U,(("2"4 +++U  $$ 5dV3qcBC IIcN Y' !AL   II*D 1  +/*C*CF ',1F )sH#J<%J/6J</J94J<<L+K--L+?L$L++L..Mc |j} | d} t| ts | j} |jj } | r| j j|nd} | %| j} | j}| j}not|} t| t| }ttt!Dcic]}|t#||c}}| rt%| ||| j |<t&|Q|ji| | ||||| |||j*|j,dz|j.|j0|j2|j4|||_||_|j:|_d|_|j>jA|_|jB|_!||_"ycc}w)N __builtins__)rvrrr)r(rGrzr|rrrrrvrrr rr$rrrr)# get_globalsrVr__dict__r(rinlined_code_cacherrvrrr"r!rrrCr-rrrUrVr rr$rrrfuncvarrr rr rEr+_allow_nested_graph_breaks)rrrrrrrr rrzr|rcachedrvrrrr\s rrVz&InliningInstructionTranslator.__init__s'') ~. *d+#,,Jmm33 =H//33D9d  !..LnnG!..L/5L  -!,/G=?Kaaq!11KL7G!-#!-8 ..t4 ==!+-*G"7%%==,,q0"22,,$66NN%  (  ))#%55::<))*C'GLsG c.|jjSr)rrrs rrz'InliningInstructionTranslator.fake_modes{{$$$rc\tj|jjSr)rr rrrs rr!z)InliningInstructionTranslator.run_ctx_mgrs ++DKK,E,E,GHHrctjsy|jsy|jj sy|j j syy)zCheck if comprehension speculation is allowed in this inlined context. Unlike should_compile_partial_graph(), this skips the exception table entry check. FT)rrr r  should_allow_nested_graph_breaksrrrs rrzAInliningInstructionTranslator._can_speculate_comprehension_nestedsE ))..||<<>{{779rctjrQ|jsy|jj sy|j j syt|Syr')rrr r rrrrUrr\s rrz:InliningInstructionTranslator.should_compile_partial_graphsO  % %22<<@@B;;;;=779 9rcdtjrt| ||St dddgy)NzGraph break in inlined functionrz2Graph breaks in an inlined call are not supported.r)rrrUrr=)rrrr\s rrz3InliningInstructionTranslator.create_call_resume_ats5  % %707PQ Q5L  rcF|j|_d|_tr)rrrrArs rrz*InliningInstructionTranslator.RETURN_VALUE s#xxz#' rcH|j||_d|_tr)rwrrrArs rrz*InliningInstructionTranslator.RETURN_CONSTs##//5#' rc2d|jvr|jdjdsv|jd}|j|}d|vr(tjj j |}n t|}t|||}t||}n[|jjd|j}t|}|j}t|||}t||}t|r t|}|||fS)Nr namedtuple_r___unnamed_scope)rzrfrrrrrrrirPr(rrRrQr]rV) rrrrr fglobals_vt global_source globals_nameglobals_sources rget_globals_source_and_valuez:InliningInstructionTranslator.get_globals_source_and_values  'z0J0U0U 1 ..4K ..{;M+-MM22LL# "0 !<?/$ >~NK&}d;M;;;;"DNNL*,7N!^^N@/$?OK-ndCM ^ $,M:M{M99rc |j}||jvr|j|S|jj|jurt ||y|j|\}}}|jjj||r6|j|jjj||y|j|}|jtj|||yr)rwrzr~r(rrUrrr+rcrFrdrgrx)rrrrrrrr\s rrz*InliningInstructionTranslator._load_global>s{{ t~~ %$$T* * ;; # #t~~ 5 G  &,0,M,Md,S )A{M{{''DD[RVW $++22<<[$OPt, ///e]KLrcl|jj|jurt||y|j }t |trtd|jdg|j}|j|\}}}|jjj|||y)Nz3Storing Tensor hook handle in globals (inline call)rr) r(rrzrUrrrVrr=rwrr+ store_attr)rrrr_fglobals_valuerrr\s rrz*InliningInstructionTranslator.STORE_GLOBALOs ;; # #t~~ 5 G  &HHJE%!89Q KK 8  ;;D.2.O.OPT.U +O[! KK $ $ / / T5 Irr) rrrrtrrrrrrrrg)rrtrztrace_rules.SkipResult) rrrrtrrrrrrrrr)rrrrrrrrrrrrr z7BaseUserFunctionVariable | LocalGeneratorObjectVariablerrrrrrrrr)rrrz#tuple[Any, VariableTracker, Source])rrrrrrrr#rrrrVrrr!rrrrrrrrr^r_s@rrr>s*++ %%+0 ))')$ ) + ) $( ) ))*?&? ??B +0 aa&a$a+ a $( a ' aaFU,@+0AD)ADAD4 AD 5 AD (B AD 3ADIAD$(AD ADF%%I      $=       (:(: ,(:TM"JJrrceZdZUded<d fd Zdfd ZddZddZddZddZ dfd Z dfd Z dd Z dd Z xZS)rrrcNt||i|g|_d|_d|_yr')rUrVrrr)rrrr\s rrVz/InliningGeneratorInstructionTranslator.__init__fs- $)&)!#( -2*rctjjfd5tcdddS#1swYyxYw)NcjSrrrsrrzEInliningGeneratorInstructionTranslator.inline_call_..ms 4CTCTr)rr(rrUrrs`rrz3InliningGeneratorInstructionTranslator.inline_call_ls8 dkk;T U *7') * * *s ?Acyr'rrs rrzCInliningGeneratorInstructionTranslator.should_compile_partial_graphpsrc|j}|jj|t|jtkDrt j tjs |jr ||_ tyr) rrrrr}rInfiniteGeneratorErrorrrrrrC)rrtops r YIELD_VALUEz2InliningGeneratorInstructionTranslator.YIELD_VALUEtsfhhj ##C( t## $'9 9,, ,  5 511#&D   2rc|jd}t|tsN|jt j |t j||gi}|j|yyrB) rrVrrrgrxr;rGrF)rrrress rGET_YIELD_FROM_ITERz:InliningGeneratorInstructionTranslator.GET_YIELD_FROM_ITERsVjjn#34 HHJ!''d3AA$rRC IIcN5rc0|j|_tr)r rrArs rr{z7InliningGeneratorInstructionTranslator.RETURN_GENERATORs#||rc0d|_t| |Sr)rrUrrrr\s rrz3InliningGeneratorInstructionTranslator.RETURN_VALUE#' w#D))rc0d|_t| |Sr)rrUrr2s rrz3InliningGeneratorInstructionTranslator.RETURN_CONSTr3rct|jdk\s td|j}|jd}|j st dddg |j |}t|jts td|jd kDs td |xjd zc_|j||j|y#ttjf$rw}t|tjrtj||j|jt!j"|j$Yd}~yd}~wwxYw) Nrr-rUnreachable sub-generator coder@Should only be encountered while implementing generator support.rrrrrr)rrrrrsr=rrVrrrFr,rrrrrmryr)rrrirexs r YIELD_FROMz1InliningGeneratorInstructionTranslator.YIELD_FROMs:DJJ1$ !KL Lhhjjjn##% 8^   ###D)Cd66<$S,,q0$%WXX  $ $ ) $ IIcN   T "'s<<= 9"c;;<--d3 HHJ II&--bhh7 8 8  9s#C++E;A-E66E;ct|jdk\s td|j}tj dk\r|j}|jd}t |ttfsgt |tr.t |jtjjs)tj dk\rt |ttfr|j!rl tj dk\rt#||\}}n|j%|}tj dk\r|j'|j'|yt3dddg yt3d d t5|d t5|d g y#t(t*j,t*j.f$rHtj dkr|j|j'||j1|YywxYw)Nrr-rrr8r6rr7rzSEND with bad typez TOS type: z(Attempted to SEND with unsupported type rU)rrrrrZrrVr|rxrr collectionsabcIteratorrrrsrrrFrrrrrr=re)rrri null_or_indexreceivernext_idxs rSENDz+InliningGeneratorInstructionTranslator.SENDsDJJ1$ !KL Lhhj   w & HHJM::b> x"24P!Q R8%>?x~~{/G/GH  G+x, )FG##%#''72(= (M) X'44T:"''72 (+IIcN< b  ,$WX%6$78FwxGXFYYZ[  ?"11**$'''1 IIcNIIdO$s45FA-HH)rrrrrrrrr)rrrrrVrrr,r/r{rrr9rAr^r_s@rrrbs<**3 * **'#R?rr)rrrztypes.ModuleType)rrJ)rrrGenerator[None, None, None])rRzCallable[..., object]rCallable[..., Any])r\rrr)rlrrr)rrryCallable[[object], bool]rFrrr)rrrr)r)rrgrrrr)ryrDrFrrrK)rrrr3rrrr)rrrrrrC)rFrr4rrzYCallable[[Callable[..., None]], Callable[[InstructionTranslatorBase, Instruction], None]])r(rErrrzCallable[[], int]rrB(r __future__rrr;collections.abcrhrErrirPrrMrrrrtrrZ threadingrrrWrrrtypingrrrr r r typing_extensionsr rtorch._loggingtorch._dynamo.dynamo_profilerr rtorch._dynamo.excrr torch._guardsrrrtorch._logging.structuredr%torch.fx.experimental.symbolic_shapesrtorch.utils._functoolsrrrrrrrrbytecode_analysisrrr r!bytecode_transformationr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2codegenr3comprehension_graph_breakr4r5r6r7r8r9r:r;r<r=r>r?funcname_cacher@guardsrArB output_graphrCrDrErF polyfillsrGrHrIrJ replay_recordrKrLr rMrNrOrrPrQrRrSrTrUrVrWrXrYutilsrZr[r\r]r^r_r`rarbrcvariables.baserdrerfrgvariables.builderrhrirjvariables.builtinrkrlvariables.constantrmvariables.ctx_managerrnrorprqrrsvariables.functionsrtrurvrwrxryrzr{variables.iterr|r}variables.lazyr~rrrrrrvariables.miscrrrrrrvariables.nn_modulerrvariables.object_protocolrrrrvariables.setsrrbrvariables.tensorrrrvariables.torch_functionrrvariables.user_definedrrrrrrrtorch._subclasses.fake_tensorrrr getLoggerrr!rgetArtifactLoggerrrrrrrmrrGrrcontainsrr rrcacher dataclassrrrr rr"rir%r+r-rrrrArCrSr]rprrrrrrrrLr]rNrarrLr_nb_opsrrUrrr)rrrrs0000rrqs0#     *II$ ROCC/</ $'L    )/  :   ;   WVRRC0 /   A/Q (2WW3<'g!..228^L11(LI>>33HnM^^55h@PQioo4R4L4R4R4T',0AqAq''''^"("3"34BB X]] + 9 9 D!H '(()y )) B IIIX     /// 33. 44 )!) ))& $!$ $$ !!!H ~  I 9A  ..&* #*&* * *Z B@&@Fe&e.2e=eP R!R'0R;LR RB4[ ["[[|JJ2 iiiXl=;'l=;^{A5AH w   FA  !#v-F12JWVABZL3I  := := :=(:=! :=:=zaJ$=aJHZ-JZ{'hhs V<$W