i  UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZddlmZmZmZmZmZmZmZddl m!Z!ddl"Z"ddl#Z"ddl$m%Z%m&Z&ddl'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1dd l2m3Z3d dl4m5Z5m6Z6m7Z7mZ8m9Z9m:Z:d dl;mZ>m?Z?d dl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOd dlPmPZPd dlQmRZRd dl6mSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[d dl\m]Z]d dl^m_Z_m`Z`d dlambZbmcZcmdZdd dlemfZfmgZgmhZhmiZimjZjd dlkmlZlmmZmd dlnmoZompZpmqZqmrZrd dlsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{d dl9m|Z|m}Z}d dl~mZmZmZmZmZmZmZmZmZd dlmZmZmZd dlmZmZmZd dlmZd d lmZmZd d!lmZmZmZmZd d"lmZmZd d#lmZmZmZmZmZmZmZd d$lmZd d%lmZd d&lmZmZmZmZmZmZd d'lmZmZmZmZmZmZmZd d(lmZmZd d)lmZd d*lmZmZd d+lmZmZd d,lmZmZmZmZmZerdd-lmZmZmZdd.lmZd d/lmZejeѫZe"jjed0Ze"jjed1Ze"jjed2Ze"jjed3ZejZejDcic]\}}|e|jc}}Zd4ed5<eejjZeejjZd6ed7<d8ed9<ee:jdeefZd:ed;<e jdpd<ZejGd=d>ZejGd?d@ZejGdAdBZejGdCdDZGdEdFZe jdqdGZej drdIZej drdJZejGdKdLZGdMdNeZGdOdPeZGdQdReZdsdSZdtdTZe jdudUZe jdvdVZe jdwdWZejGdXdYZ dxdZZd[Z dyd\Z dzd]Z d{d^ZGd_d`eZejGdadbZGdcdHedZGdedfeZej dgk\r9ejDcgc]\}}eedh|vr|didndj|did!c}}Z ej d|dkZ GdldmeZ Gdndoe Z ycc}}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)deque)AnycastNoReturnOptional TYPE_CHECKING TypeAliasUnion)TypeIs)DynamoProfilerStateFunctionTraceTiming)ObservedExceptionTensorifyScalarRestartAnalysis)InlinedCodeCachetracingTracingContext) dump_file) guard_bool) cache_method)configexcgraph_break_hintslogging trace_rules variables) get_indexof JUMP_OPNAMESlivevars_analysispropagate_line_nums)cleaned_instructionscreate_binary_slicecreate_call_functioncreate_call_function_ex create_copycreate_dup_topcreate_instructioncreate_jump_absolute create_rot_n create_swap get_code_keys Instruction is_generatoris_jump_absolute unique_id) code_context) PyCodegen) !augment_exc_message_with_hop_nameBackendCompilerFailedcollapse_resume_framesformat_frame_infoget_stack_above_dynamoResumePrologueTracingErrorStepUnsupported unimplemented Unsupported) get_funcname) GuardBuilder install_guard)GraphCompileReason OutputGraphStackLocalsMetadata)impl_CONTAINS_OP_fallbackimpl_IS_MAPPINGimpl_MATCH_CLASSimpl_MATCH_KEYSimpl_MATCH_SEQUENCE) DummyModuleExecutionRecorder)ContinueExecutionCache"IS_TRACING_RESUME_PROLOGUE_VARNAME ReenterWithTORCH_DYNAMO_RESUME_IN_PREFIX) AttrSourceDictGetItemSource GlobalSourceGlobalWeakRefSourceLocalCellSource LocalSourceSkipGuardSourceSource)is_builtin_constant is_forbidden) _get_error_on_graph_breakcountersget_fake_valueget_instruction_source_311get_metrics_contextgraph_break_dup_warning_checkeristype LazyStringproxy_args_kwargs)typestrValueMutationNewVariableTracker)FrameStateSizeEntryVariableBuilder wrap_fx_proxy)BuiltinVariable)CONSTANT_VARIABLE_NONEConstantVariable)ContextWrappingVariableGenericContextWrappingVariableWithEnterFunctionVariableWithExitFunctionVariable)ConstDictVariable SetVariable)BaseUserFunctionVariableLocalGeneratorFunctionVariableLocalGeneratorObjectVariableNestedUserFunctionVariableSkipFunctionVariableUserFunctionVariableUserMethodVariable)MAX_ITERATOR_LIMIT)LazyVariableTracker)BaseListVariableIteratorVariableListIteratorVariable ListVariable SliceVariable TupleVariable) CellVariableExceptionVariableGetAttrVariable NullVariablePythonModuleVariableTracebackVariableUnknownVariable)NNModuleVariableUnspecializedNNModuleVariable)SymbolicStreamState)supported_comparison_opsSymNodeVariable)SymbolicTorchFunctionStateTorchFunctionModeVariable)RemovableHandleVariableUserDefinedClassVariable!UserDefinedExceptionClassVariable"UserDefinedExceptionObjectVariableUserDefinedObjectVariable)Callable GeneratorSequence)FakeTensorMode)CompilePackage graph_breaks trace_call trace_sourcetrace_bytecodedict[str, Any]compare_op_handlersc2t|gt|iSN)handle_containsreversedtxargs_s o/var/www/vps2.regionflexible.com/Desarrollo/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_failedNzOptional[bool]error_on_graph_breakzOptional[GraphCompileReason]reasoncd|_||_|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_analysissB $8! ;; "![[//N@N,,NKKrc\|jr |jJ|j|_yyNTF)rr)rrs rfailedzSpeculationEntry.faileds/ <<,,8 88&*&?&?B #r)rrreturnNone)rInstructionTranslatorBaserr) __name__ __module__ __qualname____annotations__rrrrrrrrrsCM K GT+/./+/F (/ LrrceZdZUdZej eZded<dZ ded<dZ d ed <dd Z dd Z dd Z y)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_gradcd|_yNr)rrs rrestartzSpeculationLog.restarts  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__ dataclassesfieldlistrrrrrrrrrrrrsn'8k&7&7&MG #ME3N*/ $.--%(-?B-JU- -rrcFeZdZUejeZded<ddZy) LocalStaterzdict[str, FrameStateSizeEntry]automatic_dynamiccbdjd|jjDS)N c3LK|]\}}|d|jyw): N)render).0kvs r z$LocalState.render..]s* %)QqcAHHJ<  s"$)joinritemsrs rrzLocalState.render\s/yy -1-C-C-I-I-K   rNrr) rrrrrdictrrrrrrrrVs%8I 8I8I95 rrc0eZdZUded<ded<dZded<y)DistributedStater compile_pgr local_stateNzOptional[list[LocalState]] all_states)rrrrrrrrrrcsO-1J*1rrcneZdZUeZded<eddZed dZed dZ ed dZ y) TensorifyStatezset[str]force_specializationsc:|jj|yr)raddclsrs r specializezTensorifyState.specializeps !!%%e,rc||jvSr)rrs rshould_specializez TensorifyState.should_specializets1111rc8|jjyr)rrrs rrzTensorifyState.clearxs !!'')rc2t|jdk(Sr)rrr s remptyzTensorifyState.empty|s3,,-22rN)rrrr)rrrrrrr) rrrsetrr classmethodrr rr rrrrrjs_'*e8+--22**33rrc4tjtSr)torchdynamo_loggingget_step_loggerlogrrr _step_loggerrs  . .s 33rrc#DK|jj}|jj} g|j_d|j_d||j_||j_y#||j_||j_wxYwwr)speculation_logrr)rrrs r save_and_restart_speculation_logrs  ((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_graphrsA$ii## %  #  sA+AAAAc^eZdZUded<ded<ded<dZded <d d Zdd Z dd Zy)BlockStackEntryr-rzInstruction | Nonetargetr stack_indexNzHOptional[Union[ContextWrappingVariable, GenericContextWrappingVariable]] with_contextc|jduSr)r#rs r can_restorezBlockStackEntry.can_restores  ,,rc*|jJ|jrbt|jdrL|jjr6t |jdz t |jjSt |jdz S)N target_valuesr)r"r#hasattrr'rKtuplers r resume_fnzBlockStackEntry.resume_fns+++   ))?;!!//  1$eD,=,=,K,K&L t//!34 4rc|jJ|r|jjs|s|jj|Syr)r#exit_on_graph_breakexit)rris_graph_breaks rr-zBlockStackEntry.exitsG  ,,, t00DDF$$))"- -rr)rrK)rrr.rrzVariableTracker | None)rrrrr#r%r*r-rrrr r sQ    - 5+=A rr c eZdZy)rNrrrrrrrrrrc eZdZy) ReturnValueOpNr0rrrr3r3r1rr3ceZdZdZy) YieldValueOpzY Signal to the symbolic tracer to stop and return control flow to the caller N)rrrrrrrr5r5srr5cttj|jt |t j |dfd }|S)Nch|jj||jiyr)push call_functionpopn)rrfn_varnargss rimplzstack_op..impls' &&&tTYYu-=rBCr)rInstructionTranslatorrr-rr)rinspect signature parametersrf functoolswraps)fnr=r;r<s @@rstack_oprEsL !!"%00 1E R F__RDD Krct|tjsy|jj ddt j vS)NF.r) isinstancetypes ModuleTypersplitsysstdlib_module_names)mods r is_stdlibrOs: c5++ , <<  c "1 %)@)@ @@rc|rdd}ndd}tj|Dcgc]}|j}}tdt |D}|j d}||dz|dzScc}w)Nc|sJdy)Nmsgrxs rrDz(get_assert_bytecode_sequence..fns OeO1rc |sJyrrrSs rrDz(get_assert_bytecode_sequence..fns H1rc3JK|]\}}|jds|yw)POP_JUMPN) startswith)rirs rrz/get_assert_bytecode_sequence..sV71d$//*:UQVs## RAISE_VARARGSr)rTrrr)disget_instructionsrr enumerater)with_msgrDrinsts begin_idxend_idxs rget_assert_bytecode_sequencerbsr  &)%9%9"%= >TT[[ >E >Vi&6VVIkk/*G Q1 -- ?sA/ctjdk\sJdd}tj|Dcgc]}|j}}t |dz |dddj dz }|j d}|||Scc}w) zNGet the bytecode instructions that precede BUILD_LIST in a list comprehension. c>tdDcgc]}|c}Scc}wNrrangerYs rrDz._get_comprehension_bytecode_prefix..fn 8$a$$$ rNLOAD_FAST_AND_CLEAR BUILD_LISTrz list[int])rL version_infor[r\rrr)rDrr_ start_idxras r"_get_comprehension_bytecode_prefixrts   w && &%&)%9%9"%= >TT[[ >E >E Qtt!2!23H!IIIkk,'G 7 ## ?sBctjdk\sJd d}d d}d d}d d}d d}||}||}||}||}|d|dd |d|dd |d|dd |dgd d S)aDiscover bytecode patterns for comprehension result handling. Analyzes sample functions to extract the opcode sequences that appear after END_FOR for each result disposition (stored, discarded, returned, consumed). Returns patterns with: - pre_store_ops: opcodes between END_FOR and first STORE_FAST - post_store_op: first opcode after all STORE_FASTs (for disambiguation) rdc@tdDcgc]}|}}|Scc}wrhri)rYresults r fn_storedz5_get_comprehension_result_patterns..fn_storeds#"1X&!&& ' c@tdDcgc]}|c}ycc}wrhrirks r fn_discardedz8_get_comprehension_result_patterns..fn_discarded!s!Hq ryc>tdDcgc]}|c}Scc}wrhrirks r fn_returnedz7_get_comprehension_result_patterns..fn_returned%rlrmcPttdDcgc]}|c}Scc}wrh)sumrjrks r fn_consumedz7_get_comprehension_result_patterns..fn_consumed(suQx(!A())(s #cttj|jdd}g}d}tj|D]e}|r|j rnU|j }|s"|j|k(s2|xst|j }|j|jg||jddzd}d}g}|t|kr8||dk7r0|j|||dz }|t|kr ||dk7r0|t|kr$||dk(r|dz }|t|kr ||dk(r||t|kr||fSdfS)zCExtract (pre_store_ops, post_store_op) from comprehension bytecode.rFEND_FORNr STORE_FAST) rr[findlinestarts__code__r\ starts_line positionsrrrrrr) rD target_liner_startedinstrposopsidx pre_store_opss rextract_patternz;_get_comprehension_result_patterns..extract_pattern+s_3--bkk:;A>qA ))"- +E5,,//Cszz[0! 0:`). Dynamo does not support tracing dynamic control flow.z1Use `torch.cond` to express dynamic control flow.gb_typecontext explanationhints)r:r FUNDAMENTALvalues rraise_jump_graph_breakz,generic_jump..raise_jump_graph_breaks8.-eW5D"..C rc |jsJd}  ||J|jr|j|j||j |j t|||j|tjd|jj|tdt|||jgd}|j!|j#|j$|} r|j||j&J|j#|j&|}t(j*dk\r%|jj-t/dgt/|j0|d } | j3||jj-| g|z|zy#t$r }|}Yd}~d}~wwxYw) Nrrzgeneric_jump triggered compilez generic_jump rr stack_popsre TO_BOOLr)r!)should_compile_partial_graphr;maybe_has_backedgeraise_loop_graph_breakf_codelog_graph_break code_optionsrr8rdebugrcompile_subgraphr?r` frame_summarypopcreate_call_resume_atnext_instructionr!rLrradd_output_instructionsr(rcopy_positions) rrr extra_msgreall_stack_locals_metadataif_nextif_jump jump_instr8rs rjump_graph_breakz&generic_jump..jump_graph_breaks 00222  "5 )  " " $  ' ' S 9    s8  % 23$(KK$@$@ %/ {;d>P>P>R=S %A% !  ,,  ! ! %   IIe {{&&&,, KK %    w & KK / /1CI1N0O P&t{{71:F   & ++YK',AG,KLY C sG G&G!!G&cJ|j}tjrBt|r4|j}|j rmt |j r|j|S|jr |||n(tdd|dgtjddd|jrJ|jjdtj gt#||fi|j|yt%|t&r|j(}t%|tj*s|d k7}tj,j.j0j3|}|s(td t5|d gtj6|j|y|jjdtj8gt#|fi}t;||t=|j>| }|jjdtj gt#||fi|j|y|j rt%|t@r>|jBr2tE|jBjGtHjJ|j r%r|jM||j|yy|jr|jr |||yt%|tNrS|jjQ|jR}|r%r|jM||j|yyt%|tTr |jW|d } t%| t^rP| ja|gi}tctc| dddd} |j r|j } | d k(rbt%| t sRtdjfjidtk| jl} tYjntp|| gt%| t trfr| rr|jM||j|yt%|t&r5|jurir|jM||j|ytdd| d|dgydr%r|jM||j|yyyyy|jsW|jw|rFty|j{|r%r|jM||j|yyt%|t&r t%|j(tj*r|ju|j} nt}|j(d k7} | r%r|jM||j|yyt%|tdjr.dr%r|jM||j|yyddl!mA}|jBN||jBr<|jr%r|jM||j|yy|y#tXjZ$r]tYj\| |jW|d} n0#tXjZ$rtYj\|d} YnwxYwYwxYw#tXj~$r*}|jr|||d|cYd}~Sd}~wwxYw)Nz>Data-dependent assertion failed (cannot compile partial graph)zvalue: zuDynamo has determined when encountering a data-dependent assert failure that it should not compile the partial graph.zUse `torch._assert()` to raise a hard AssertionError when the check fails. This error will propagate back the user code that called the compiled function (i.e. Dynamo will not trace any exception handling).zRemove the assert statement.zMove the assert statement outside of any context managers in order to graph break with partial graph compilation (if fullgraph=False).rr9rz#Assertion failed on symbolic shapesr) example_value__bool____len__rDrz&__bool__ should return bool, returned rz3Data-dependent branching with non-constant __bool__zmethod: z , result: z}Attempted to perform data-dependent branching on a user-defined object with a __bool__ method that did not return a constant.Tr)rr)is_constant_source)Crr rewrite_assert_with_torch_assertris_python_constantras_python_constantjumprr:rr is_tensorr create_proxytorch _assert_asyncr_rHrsym_numSymBoolfx experimentalsymbolic_shapes expect_truer USER_ERROR scalar_tensorrerYnodermsourcer> make_guardr=SEQUENCE_LENGTHr8r get_submodule module_keyr var_getattrrObservedAttributeErrorhandle_observed_exceptionrur9getattrrrhrtyperraise_observed_exception TypeErrorr evaluate_exprhas_unpack_var_sequencerunpack_var_sequencer UserErrorBackwardHookVariablerget_real_value)rrrrsym_exprrwscalar_to_tensor_proxyscalar_to_tensorrNrT method_name result_valuerR eval_resultrrrr8rrs rinnerzgeneric_jump..inners!%  3 36tXtL)-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 %%dJ7!/0r26%gat&L"j0LRV9W'88??DT,EWE`E`Dab44YC5Q!,s <,AW IIe, $8++- IIe, $! U"*1#Zx @%X D> %(IIdO". BX<."u'D'DT'JE55d;<=IIe$ $> /  emmU]];"'"5"5dkk"BK",U]]a-?"@K  $IIe$ $%y== >~IIe$ $ 3||',>u||,LE0023 %(IIdO4 'u-c-- --d3))$ :A1111$7A  v== 446+D$2aSRR s[[2;A]%2(]"\.-]".*]]"]]"!]"%^"8^^"^^")rrbrr)r) rrrr-rrbrrrrrrrr-rrr)rr8rrrs`` @@r generic_jumprs[   7M'7M7M7M 7M  7Mrw.w.r Lrc6g}|}| |j||j}| t|D]}|jD]}t |j t r:|j|jj|j|W|j Jt |j tsJ|j j||j|jj|j|y)zsGenerates bytecode to restore the block stack for running the unsupported instruction in the compiled bytecode.N)rparentr block_stackrHr#r extend_outputr*try_except_torch_function_moderrireconstruct_type try_finally)rcgcleanupall_txescur_txbs r_reconstruct_block_stackrs 13H24F    x R RA!..*CD  KKM@@ >>- --ann/FH HH NN + +B /   Q[[]66rP Q RRrc  dfd }|S)Ncjtjdfd } dfd |S)Nc |j}|_|j}|j|r"|jJ|||jS ||||_S#t$r)}|j rW|j s |jr|jtdd|j ddgtj||jr|js|jr|j|j ||j#|j$dt'|||j|j)dt+|j,|j.|_Yd}~nd}~wwxYw ||_n #||_wxYw|j1|jy) Nz0Graph break under GenericContextWrappingVariablez!Active generic context managers: z]Attempted to graph break in an active context manager(s) that doesn't support graph breaking.zEMove the offending context manager(s) to outside the compiled region.rrrrfrom_excz: r graph_break)current_instruction_push speculaterrr;active_generic_context_managers one_graphrremove_from_statsr:rCAUSED_BY_EARLIER_GRAPH_BREAK skip_framerrrrrrr add_to_statsr?rR real_stackr) rr prev_push speculationexcphandle_graph_breakinner_fn msg_prefixr8s rwrapperz>break_graph_if_unsupported..decorator..wrappers55I,0D )..*K!!$'"))555)$k6H6HII) :d+P1:-O% S77~~)B)B**,! R"CDDhDhCi j%Dc.LL"& ??88:**,// TB$$%%(\s4yk:% &&(!!-0%7$//%R ""K% SJ#09- -  1 1$2K2K Ls+A)) F3DFF(FF(( F1c<tjdk\rtjdkrs|jdk(rdtjtj d|j tjtj d|j z}n*tj|j|j }tjd|j|jj||t |z }t|jj}g}t||||jj!|j#~tjdk\r|jdk(r|j$|j$j'nd}t)|dkDr|y)Nre rdCALLPRECALLz%s triggered compilerrrrKW_NAMESrFrn) rLrrrr[ stack_effectopmapargopcoderrrrrr2root_txrrr\kw_namesrrr(r$rr!copy exn_tab_entryr:r8rrr) rrrr2rrrr7 call_insts inst_copyr8s rr'zIbreak_graph_if_unsupported..decorator..handle_graph_breaksy   G+$$w.KK6) #//IIi($(( $$SYYv%6A B  #// TXXF II,dkk :(, (D(DVD L0H)E) %4;;../B)+G $T2w 7 KK / /0C0C0E F7*t{{f/D}}0MM446 x=1$++g555KK77+JxHIxx+++1$((EB 2--d3 33J?{{*** IIdO *. ' 33YK@ KK / / 8 IIc$i,. / /+, KK / /**))- rr)rrrr-rr?rr)rBrC)r(r*r'r)r8s` @r decoratorz-break_graph_if_unsupported..decoratorsT  "2 M #2 Mh< +< < '<  < |r)r(Callable[..., None]r8Callable[[InstructionTranslatorBase, Instruction], None]r)r8r)r<s`` rbreak_graph_if_unsupportedr?s$ v%v Avp 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__.._missing]sS 2!(+dV4[\b[ccef;F8D__'22 r)rrrrrr) super__init__r[r3rrrBpartialrjgetdispatch_table) rrbasesdctrFroprLrY __class__s rrIz"BytecodeDispatchTableMeta.__init__Zs uc* "iioo/  VY%6%6x%HI I  >C4[In003I  Js ,B4B) rrrrrMrrNrrr)rrrrrI __classcell__rPs@rrArAWs^JJrrAceZdZUdZej eZded<ej dZ ded<dd Z dd Z dd Z dd Z dd ZddZ ddZddZddZddZddZddZeZy)ExceptionStackzU Exception stack that it is shared among all InstructionTranslator instances rzlist[ExceptionVals] _exc_stackN)defaultzOptional[ExceptionVals]_current_exceptioncd|_yrrWrs rclear_current_exceptionz&ExceptionStack.clear_current_exceptions "&rc4|j|||_yr)._set_context_and_break_context_reference_cyclerWrvals rset_current_exceptionz$ExceptionStack.set_current_exceptions ;;C@"%rcv|jJ|j|j|jyr)rWrrZrs rmove_current_exception_to_stackz.ExceptionStack.move_current_exception_to_stacks2&&222 D++, $$&rc6|jJ|jSrrYrs rget_current_exceptionz$ExceptionStack.get_current_exceptions &&222&&&rc|jx}rt|tur|St|j|zdkDr5|j|}|j ||dz |j ||SNrr) __context__rrhrrU_set_context_recursive set_context)rr^prev_idxctxprevs rrgz%ExceptionStack._set_context_recursivesm?? "C "S 9I(IJ t ( *Q .??8,D  ' 'hl ; OOD ! rc|x}}d} |j}t|tury||ur|jty|}||ury|r |j}| }Qr)rfrrhrhrg)rr^oslow_oslow_update_togglers r_break_context_reference_cyclez-ExceptionStack._break_context_reference_cyclest F"mmGG} 00#~ 45AF{!++%7!7 %rcv|j|t|jdz |j|yrh)rgrrUrpr]s rr\z=ExceptionStack._set_context_and_break_context_reference_cycles0 ##CT__)=)AB ++C0rc6|jjSr)rUrrs rrzExceptionStack.pops""$$rc:|jj|yr)rUrr]s rrzExceptionStack.appends s#rc,t|jSr)rrUrs rrzExceptionStack.__len__s4??##rc |j|Sr)rU)rrs r __getitem__zExceptionStack.__getitem__su%%rc:d|jd|jS)Nzself._exc_stack=z - self._current_exception=)rUrWrs r__str__zExceptionStack.__str__s""$//##?t'>'>&@AArr)r^rrr)rr)r^rrirrrr)rrrrr)rrrrrrrrUrrWrZr_rarcrgrpr\rrrrvrx__repr__rrrrTrTqs'8k&7&7&MJ#M2C+2C2CD2Q/Q'&' '   ,/   861 1 1%$$&BHrrTceZdZUded<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 ddd=Z dd>Zdd?Zdd@Zej$dAk\rddBZnddCZeddDZddEZddFZddGZddHZddIZddJZd dKZddLZddMZddNZddOZ ddPZ!eZ"d dQZ#ddRZ$ddSZ%e&jNddTZ(ddUZ)ddVZ*e+d dWZ,d dXZ-ddYZ.ddZZ/e/Z0dd[Z1e+d d\Z2dd]Z3dd^Z4e4Z5e4Z6e7e8jrd_Z:e7e8jvd_Z<e7e8jrd`Z=e7e8jvd`Z>ddaZ?ddbZ@ddcZAdddZBddeZCddfZDddgZEddhZFddiZGddjZHddkZIddlZJddmZKddnZLddoZMddpZNddqZOddrZPddsZQddtZRdduZSddvZTddwZUddxZVddyZWeXd`dz{dd|ZYeXd`d}{dd~ZZeXd`d{ddZ[ddZ\ddZ]ddZ^ddZ_ddZ`ddZaeXd_d{ddZbddZced ddZe ddZf ddZged ddZhddZieXd_d{ddZjddZkddZlddZmddZnddZoddZpddZqerfddZsddZtetZuddZvddZwewZxddZyddZzddZ{ddZ|ddZ}ddZ~ddZddZeXd_d{ddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZeZddZddZddZddZddZddZddZddZee8j:Zee8j>Zee8jrZee8jDZee8jHZee8jLZee8jPZee8jTZee8jXZee8j\Zee8j\Zee8jbZee8jfZeXd`d{ee8jjZee8jnZee8jrZee8jvZee8jzZee8j~Zee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZee8jZېddZej$dAk\rddZݐdd„ZސddÄZߐddĄZdddńZeXd`dƬ{ddDŽZddȄZddɄZe4Ze4Ze7e8jvd_Ze7e8jvd_Ze7e8jrd_Ze7e8jrd_ZddʄZdd˄Z dd̄Zedd d̈́Zdd΄ZddτZddЄZddфZdd҄ZddӄZddԄZddՄZddքZddׄZdd؄ZeXd`d٬{ddڄZddۄZdd܄Zdd݄ZddބZdd߄ZeZeZeZdZddZddZdZddZddZ d d!dZ d"dZ ddZ d#dZ ed$dZ ej d%dZd&dZddZd'dZd(dZddZ d)dZ d*dZ d+dZ d,dZ d-dZedd.dZ d/ d0fd ZxZS(1rr@rdict[str, VariableTracker]symbolic_localssymbolic_globalsrsymbolic_torch_function_statersymbolic_stream_statez$Optional[dict[str, VariableTracker]]post_prune_cell_and_freevarslist[VariableTracker]stack Optional[int]rr-current_instructionrrzlist[BlockStackEntry]r rrzOptional[ConstantVariable]r7accept_prefix_instlist[Instruction] prefix_insts inline_depthinconsistent_side_effectszOptional[SpeculationEntry]current_speculationz list[Any]rLrT exn_vt_stackzOptional[ExecutionRecorder] exec_recorderz+Optional[Callable[[VariableTracker], bool]]strict_checks_fn start_pointhas_no_inlined_callsz#Optional[InstructionTranslatorBase]r is_child_tracer_activez3list[tuple[VariableTracker, list[VariableTracker]]] debug_localsOptional[CompilePackage]packagez deque[str]latest_bytecode_queuecd|_y)z InstructionTranslator has encountered instructions which may cause dynamo to see a different version of history from eager See: https://github.com/pytorch/pytorch/issues/110765 TN)rrs rmark_inconsistent_side_effectsz8InstructionTranslatorBase.mark_inconsistent_side_effectss *.&rc|}||jj}|jJ|j|jdD]8}|jdvrn(|jt vs&|j }||ks8y|j}|y)N) RETURN_VALUE RETURN_CONSTTF)roffsetrrrrrr )rr cur_offsetr jump_offsets rrz,InstructionTranslatorBase.maybe_has_backedges*7; 33::J--9 99++F,F,F,HI $;;"BB;;,."&++K"Z/#  $]]F rc |jdS)N co_cellvarsrrs rcellvarsz"InstructionTranslatorBase.cellvars$  //rc |jdS)N co_freevarsrrs rfreevarsz"InstructionTranslatorBase.freevars'rrc~t|ds&|j|jz|_|jS)N_cell_and_freevars)r(rrrrs rcell_and_freevarsz+InstructionTranslatorBase.cell_and_freevars*s2t12&*mmo &GD #&&&rcV|jjDcic]\}}||jvr||c}}|_t |j |j }|jjDcic] \}}||vs ||c}}|_ycc}}wcc}}wr)r|rrrr rr)rrrreadss rprune_dead_localsz+InstructionTranslatorBase.prune_dead_locals/s,,224- 1D**,, qD- ) "$"3"3T5M5MN!11779 QQ%ZAqD -  sB B%B%ct|tsJt|tsJt|tsJt dt j ||jDsJd}t|dr |j}t|dr |j}|r$t|rt|rtd||j|j|||y)Nc3<K|]}t|tywr)rHrb)rrTs rrz:InstructionTranslatorBase.call_function..Es  q/ * rrDz$Attempt to trace forbidden callable )rHrbrrall itertoolschainvaluesr(rrDcallablerVAssertionErrorr8r9)rrDrkwargsr(s rr9z'InstructionTranslatorBase.call_function<s "o...$%%%&$''' __T6==?;     2w xxH 2t uuH *|H/E #Gz!RS S """4v67rc^t|ts t|}|j|||S)zD Redirect the call to the generator "call_function" )rHrpr9rrDrrs rinline_generator_functionz3InstructionTranslatorBase.inline_generator_functionRs."<=/3BdF33rctjr,t|jr|j |||St j ||||S)zF A call to some user defined function by inlining it. )r"enable_faithful_generator_behaviorr.get_coderInliningInstructionTranslator inline_callrs rinline_user_function_returnz5InstructionTranslatorBase.inline_user_function_return_sF  4 4bkkm9T11"dFC C0<[[F7;7H7H17Lt001 3RT   7 7@%-rRz3C ++))*!F84 8K8K7L\N[kZlmmrcd|jd}tj|jj|j j }|d|z }|S)NzTRACE starts_line rz )r linecachegetlinerrrrstrip)rlog_strlines rget_log_starts_line_log_strz5InstructionTranslatorBase.get_log_starts_line_log_strwsX&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_logrr^r)rrs rrz%InstructionTranslatorBase.starts_line}sl ;;&  && KK # #VT[[-@-@   + +  " "4D4T4T)U V ,rct|_|j}|y|j|x|_}|dz|_|j r|j |j |j sb|jrR|jrB|j|_ |jj|r|j|y|jr?tjd|j |j"t%|j t&j(rW t%|j }|j,j/d|j dt%|j"d||j1| |j2|j4|||j6j8 S#t*$rd}YwxYw#t:$rt<j>$r}|jA|Yd}~yd}~wtBtDf$rYytFtHf$r}|jJs4|js(|jLstO|tFr>|jPr2tO|tHr!tSd d d d d gtTjV|jatXjdtO|tHr"tSdd dd dgtTjVdtO|tFsJd|_(dt[|}|j]|j^||Yd}~nd}~wwxYw|jja|jy)zzTRACE  Tz3cannot resume from torch._dynamo.step_unsupported()rztraced torch._dynamo.step_unsupported(), but Dynamo is instructed to error on graph break. This graph break is used for debugging only.z1Remove the torch._dynamo.step_unsupported() call.z9Make sure fullgraph=False and error_on_graph_break=False.rz1empty checkpoint - cannot resume from graph breakz6torch._dynamo.step_unsupported() with empty checkpointztraced torch._dynamo.step_unsupported(), but there is no checkpoint to step_graph_break from. This graph break is used for debugging only.zInclude at least one checkpoint: (1) include at least 2 ops and (2) make sure there is some line of code that is not in a try/with block, and has an empty Python stack.)rrrrr!zEncountered graph break that we cannot resume from. Compiling up to the previous resumable state, then skipping the rest of the function. Graph break encountered: r)1rWrrrrrrris_non_empty_graphrrrstep_graph_breakis_trace_bytecode_log_enabledtrace_bytecode_logrrrreprrverbose ValueErrorrrupdate_block_stackrLr5rrrrrexception_handlerr3r5r;r9ris_tracing_resume_prologuerHr!r:r DYNAMO_BUGrrrrr)ripr stack_reprrrs rstepzInstructionTranslatorBase.steps4$=$?!  % % :*.*;*;B*?? 4#%6      T-- . 113'')'+~~'7D $''..t4%%d+  - -  $ $ $++t{{D> P!$**-   & & - - QtDKK'8&9:,G  %B  ,D   ,T4 8{{... . PO  P.  $$   " "1 %|, _-8 ,,22q+.1<<a1! U "%`PW/99 ''/ MNa1! X "%aPk/99  $( "![111# /031vh8   !! !  i8 t   ::4;T;TUs=0G6G  GG M <HM &M 5D MM r,c|j}|rt|jdk\rg|j|jdjurA|j|jdjur|jj yyyy|jrD|j dvr5t|jdk(sJ|jj yyy)Nrn)NOP JUMP_BACKWARD NOT_TAKENr)r9rr r!rr)rrrs rrz,InstructionTranslatorBase.update_block_stacks&&E (()Q. D,<, |jjrJ|jJ|jrJtj d|jj |td|jg}|jrTddl m }tjsJt|jj}|j!gt#d|j%d|j't)dd t#d|j%d|j't)dd |j+d||dg|d d \}}||g}t-|j|||j/|g|g||j!||j!gt#d|j%dt)d t#d |j%dt)d |dj0}|j!gt#d|j%d|j't3d||j!gt5dt)dd |jj7t9|dxj0dz c_|dkDrz|j!gt#d|j%d|j't;t3|dt5d|j%dt)d|j!t)d|dz t)d|dz t)d|dz g|jj=|j?|jjA|jjB|ddzy|jj=gt5dt)dt|jj}|jj=|j%d|j'g|djDjGD]X\} } |jj=t;|j%| |j'|jI| gZ|jj=t)dtK|g|jLy)Nzstep triggered compilestep_unsupported)rr skip_coderrrpr4TF DELETE_SUBSCRre LIST_APPEND STORE_SUBSCRUNPACK_SEQUENCEPOP_TOPrn)'routput_instructionsrrrrrr?rr  eval_framerrnested_graph_breaksr2r6r r&create_load_constcreate_binary_subscrr( create_resumercodegen_call_resume num_stackr#r+r8rr'rr\rr locals_namesr create_storer)r) r continue_instrrrleaf_resume_codeleaf_resume_namerrlocalrs rrz*InstructionTranslatorBase.step_graph_break1sF;;2222''333::~ *+$(KK$@$@ %&84;M;M;O:PQ%A% ! ;; --- --4;;../B     ^ ((+ ++- '|;  !^  ((+ ++- '|;  261C1C=";A">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|jjOt)|t,r5|jjQ|jjS dddy#t$rY}|jrGtdt|jdt|j|j dd}~wwxYw#t"$rt$$rt&$r}t)|t*rTt)|t,rD|j.s8|j0s,dt|}|j3|j4||t7|drpd|j8vrbt:j<j?|jj@|jjBjEddd }||_#d}~wt$r1}|jHr|jHjK|_&d}~wwxYw#|jjOt)|t,r5|jjQ|jjSwwxYw#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: rrRzData-dependentFT) print_outputinclude_strideinclude_device)*rrrrrpush_txrrr Exceptionrr8rrrwith_traceback __traceback__rr4 RuntimeErrorrHr;r>rrrrr(rRrr GraphModule nn_modulesgraphprint_readablepartial_fx_graphr get_record exec_recordpop_txrmark_bytecode_tracing_stop)rrrreadable_graphs rrunzInstructionTranslatorBase.runs    G = dkk-- .E = ##D)#'#;#;  ))+))+j ""$ d$9:KK'') KK::? 55 NN77:1vh@ (())%) 1e$)9QUU)B%*XX%9%9 .. 0A0A&$n%*4PT%# *8A& %%$($6$6$A$A$CAM    ""$ d$9:KK'') KK::< ;CG =G =sh K.,E!C)AK.) E 2AEE  EJ)C!I  J,JJJ  A!K++K..K7c|#t|tsJdt||jj |y)Nz"push expects VariableTracker, got )rHrbr`rrr]s rr8zInstructionTranslatorBase.pushEs?{jo> 0 ? > #rc4|D]}|j|yrr8)rvalsr^s r push_manyz#InstructionTranslatorBase.push_manyKs C IIcN rc6|jjSr)rrrs rrzInstructionTranslatorBase.popOszz~~rcpgtt|Dcgc]}|jc}Scc}wr)rrjr)rnrs rr:zInstructionTranslatorBase.popnRs*: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) NrGimplicitz5Attempted 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)rrf_locals add_local_varr8r|unwrapKeyErrorrXreplacer:rrr)rrrnew_names r LOAD_FASTz#InstructionTranslatorBase.LOAD_FASTUsP{{   $$--"7    , ,T4==3F G  IId**40779 :4 ??9 %  $ $T * &3 s# #||C|jj|j|j|jyyyr) rrr|r side_effects load_cellr8rr&r')rrcell contents_vars r LOAD_DEREFz$InstructionTranslatorBase.LOAD_DEREFxs{{d446666##DKK0{{//99$?  ,   $++">    , ,T[[$-- :T U#? rc|j}|j}|j|||j|<|tk(r+|j }t |tusJ||_yyr) rr set_name_hintr|rJrrrr)rrr loaded_vtr^s rrz$InstructionTranslatorBase.STORE_FASTsj{{HHJ %%.T" 5 5..0C9$ $$.1D + 6rc2|j|j=yr)r|rrs r DELETE_FASTz%InstructionTranslatorBase.DELETE_FASTs   -rcR|j|jvsJ|j|j}|j}|jj j ||t|tsJ|j|j|jyyr) rrr|rrr. store_cellrHr~ local_namer4)rrr0r^s r STORE_DEREFz%InstructionTranslatorBase.STORE_DEREFs{{d446666##DKK0hhj   ++D#6$ --- ?? &   doo . 'rc|j}| tj|jS|j|}|s'>T[['QD ! !! $''*C rcD|j|j|yr)r8r>rs rrz$InstructionTranslatorBase.LOAD_CONSTs $""4()rc |j}|jrn||jvr*|jj||j|n6||jvsJ|j||jj |<||jvr|j |S||jvr\|jj|j|}|j|jjj||y|j|}|jtj||t|yr)rr f_globalsadd_global_var f_builtinsbuiltins load_builtinr}rr.r8 load_globalrbbuildrO)rrrvariablers r _load_globalz&InstructionTranslatorBase._load_globals{{   t~~%""11$t8LMt...48OOD4I""++D1 t~~ %$$T* * 4(( ({{//0E0Ed0KLH IIdkk..::8TJ K t$ /''e\$5GHIrcld}|j|}t|}tj|||S)Nztorch.nn.modules.module) import_sourcerrbrG)r module_name module_sourcefglobals_values rnn_modules_globals_vtz/InstructionTranslatorBase.nn_modules_globals_vts6/ **;7 ' 4$$T>=IIrc8|jJtjdk\r3tjdkr |jdzr|j||j |tjdk\r"|jdzr|j|yyy)Nr,rr)r4rLrr PUSH_NULLrIrs r LOAD_GLOBALz%InstructionTranslatorBase.LOAD_GLOBALs~xx###   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) rrrOr}objectrr.track_global_existingrHrr: store_global)rrrrrrHs r STORE_GLOBALz&InstructionTranslatorBase.STORE_GLOBALs {{d# t,, ,*0(D ! !$ ';;++AA D))$/  e4 5 ?4     --heDrcd|vrZtjjj|}|j ddj ddj dd}n t |}d|j dd}|j|jj ||||jj|<|jj}||vs |||usJ|||<|jj|t|S)z-Create an alias to a module for use in guards torch_package>r,7 ""5)KK,, I%5)9U)BBB % ##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 rGrz2attempted 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)re) stacklevelzYcan't resolve package from __spec__ or __package__, falling back on __name__ and __path__r__path__rGr)rArKr rwarning 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)fromlistriglobalszImport failurez module_name: z , fromlist: z, level=z"Failure when attempting to import.rrrGrzBad import resultz%Import result is not a Python module.)r:rrrHLOCAL_MOD_PREFIXrArO __import__rhr:rrrurl partitionrKr add_local_modr]rIrJrGr8rr`) rrrirwrL 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 %%**K8 9 II*5@ A +C  A ,+K= XJhW\V]^ D9-889  sE>>1F32F3c\|j||j|jyr)DUP_TOP _load_attrrrs r IMPORT_FROMz%InstructionTranslatorBase.IMPORT_FROM`s T  $rcb||jvr#tddd|dgtj|j|}t |rBt |j j}t||}tj|||St|sJtj|S)Nz%failed to find name in frame builtinsrzFailed to find name `z` in frame's builtins.rr)rCr:rrrrOr%name_of_builtins_dict_key_in_fglobalsrNrbrGrUrhr)rrr^builtins_source var_sources rload_builtin_from_argvalz2InstructionTranslatorBase.load_builtin_from_argvalfs  ( ?3F8;QR&11  oof% C=* AAO+?FCJ"((sJ? ?&s+ ++#**5 5rcX|j|j|jyr)r8rrrs rrEz&InstructionTranslatorBase.load_builtin}s $// <=rc|jJ|jJ|jJtj d|j|jz |j |j|_|j|_y)Nir_count)rrr!r[ incrementindexofrs rrzInstructionTranslatorBase.jumps''333+++{{&&&'' 0043C3CC $(<< #< 33rFTc |jJ|jjt||jt |j yrr!r rr rrrs r SETUP_LOOPz$InstructionTranslatorBase.SETUP_LOOP;{{&&& dkk3tzz? STrc |jJ|jjt||jt |j yrrrs r SETUP_EXCEPTz&InstructionTranslatorBase.SETUP_EXCEPTrrc8|jjyr)r rrs r POP_BLOCKz#InstructionTranslatorBase.POP_BLOCKs rc&|j|yrsetup_or_before_withrs r SETUP_WITHz$InstructionTranslatorBase.SETUP_WITH !!$'rc |jJ|jjt||jt |j yrrrs r SETUP_FINALLYz'InstructionTranslatorBase.SETUP_FINALLYs;{{&&& dkk3tzz? STrc&|jdyrrrs r BEGIN_FINALLYz'InstructionTranslatorBase.BEGIN_FINALLYs  $rc|jd\}}|J|j||j|j|tgdziy)Nrre)r:r8r9rg)rrr-rs rWITH_CLEANUP_STARTz,InstructionTranslatorBase.WITH_CLEANUP_STARTsLIIaL c{{ # $$$T,B+Ca+GLMrcH|jd|jdyNr)r:r8rs rWITH_CLEANUP_FINISHz-InstructionTranslatorBase.WITH_CLEANUP_FINISHs !  $rc|jj}|j| |j|}|j|y#tt j f$r}t|t j rt j|tjdk\r|jtn|j|j|Yd}~yd}~wwxYwNrd) rrealizer8 next_variable StopIterationrObservedUserStopIterationrHrrLrrrgr)rritr^rs rFOR_ITERz"InstructionTranslatorBase.FOR_ITERs XXZ   ! "  ""4(C IIcNs<<= !S::;--d37*  01 IIdOO s"AC0-A9C++C0clt|tjtfr|j |gi}|Sr)rHrrfrr9r]s r_create_exception_typez0InstructionTranslatorBase._create_exception_types6  )++-NO ##D"b1C rc|j}|j|d}t|ttfsJt j ||}|j |dtd|giy)Nr  __setattr__)rrrHrhrfrom_frame_summary call_method)rrrtbnew_tbs r_attach_traceback_to_exceptionz8InstructionTranslatorBase._attach_traceback_to_exceptions~**, S__     !#45   #55mRH   o . 7   rc|j|}t|jrVt|tj r<|j tur*t jtj|gi}|j|r:t|dd-tjjj!|_|j|rT|j$j'|t)j*|j }t|dd}|d||t-dt/t(dgt0j2y)N python_stackraised exception )r#zFailed to raise exceptionz.Attempted to raise a non-Exception type/value.r)rr.rrHrrexc_typerrfrr9_isinstance_exceptionrr_guardsr extract_stackrrr_rget_dynamo_observed_exceptionr:rrr)rr^observed_exception_typers r_raise_exception_variablez3InstructionTranslatorBase._raise_exception_variables ))#.  %3 ; ;< -++L9GGbRTUC  & &s +^T2:$}};;IIKC   % %c *    3 3C 8&)&G&G &U #"3=L)#C5)l  /HH1%001  rc"|jdk(rt|js(td}t j t ||gt|jsJ|jd}|j|sJ||j|y|jdk(rM|jd} |j||jj}|j|y|j}|j} |j||jj}|j||j|}|j|td|y#|jj}|j|wxYw#|jj}|j||j|}|j|td|wxYw)NrzNo active exception to reraiserrnr __cause__)r4rrrhrrrrrrrcrrr call_setattr)rrrRr^curr_excfrom_vtcauses rrZz'InstructionTranslatorBase.RAISE_VARARGS s 88q=t(()&'GH,,\4seLt(() ))##B'C--c2 7C 72  * *3 / XX]**R.C >..s3 ,,BBD33H=hhjG((*C R..s3 ,,BBD33H=33G<%%d,<[,I5Q ,,BBD33H= ,,BBD33H=33G<%%d,<[,I5Qs<FF4-F14AHc|jd}t|tsJ|jturt dddgy|j |y)Nrnz CLEANUP_THROW with StopIterationrzRReceived StopIteration when handling generator.throw/close. This is not supported.r)rrHrrrr:RERAISErrtoss r CLEANUP_THROWz'InstructionTranslatorBase.CLEANUP_THROW7 sNjjn#0111 <<= ( :p   LL rcntjdk\ra|j}|jr"|j}|j |y|j ||j |y|j}|j}|j}|j |y)Nr,)rLrrrrrr8)rrr^r_exc_tbs rrz!InstructionTranslatorBase.RERAISEE s   w &((*C{{HHJ..s3 #..s388:D((*C((*C  * *3 /rc"t|tSr)rHrr]s rrz/InstructionTranslatorBase._isinstance_exception\ s#}--rcg}tjdk\rtjdkrdnd}t|j|k\sJ|j| }|jd}|j |sJt |j }|j|d}tjdk\rt|jdts|j|jdnrt|jdk\sJ|jd }|jd }|j |sJt |j }|j|d}||||gz }|j||iy) Nr,rernr ir) rLrrrrrrfrrrHrrr9)rrrfn_locrDr^typrs rWITH_EXCEPT_STARTz+InstructionTranslatorBase.WITH_EXCEPT_START_ sN&(   w &**W4Q!Ftzz?f, ,,VG$B**R.C--c2 22!#,,/CB 7*!$**R.,?KK 2/tzz?a' ''BB**R.C--c2 22!#,,/C7B c2 2tR(rc   d d fd }tjdk\rKjj}|rt j |j kDr3jt j |j kDr3|jr8jtjjjjjjj|yj j!jj}j#|t%t&ur|t j(r7j(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 }jtjDj|jtjF|jHn]jtjJjtjJjtjJjtjDj|jtjF|jHj|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.c:jj}tj|j }t |sJt dd|jd|jdgtjtjy)NzObserved exceptionrrrr) rrcrr python_typerHr:python_type_namerrrrE)r dynamo_excobserved_exn_gb_explanationraised_exceptionrs rbubble_exception_to_interpreterzTInstructionTranslatorBase.exception_handler..bubble_exception_to_interpreter s((>>@H::8;O;O;QRJ. ; ;; ,+H,E,E,G+H(--XYZ7&11&22* rr,EXCEPT_HANDLERrerz#Observed exception (EXCEPT_HANDLER)z This graph break is unexpected.rg.Arrr)&rLrrrr9rrdepthrlastir8rrhrrrcrrrrr>r rrr:r:rrrrar"r-rrr rrfrrg) rrrr9rblock_stack_entry exception_varexcept_handler_inst old_exceptionrs `` @rrz+InstructionTranslatorBase.exception_handler s d $     w & 44BBM $**o (;(;;HHJ$**o (;(;;!&&II!2243K3K3R3RS  $++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(>?IIi>>?IIi>>? )3356 -( )33M4J4JKL +,   ":!6635&&rc|j}t|jdk(rt}n|jd}|j ||j ||jj y)Nrrn)rrrrgr8ra)rrr^prev_excs r PUSH_EXC_INFOz'InstructionTranslatorBase.PUSH_EXC_INFO s`(hhj t  !Q &(>H((,H ( # 99;rctjdk\rB|j}t|jsJ|jjyt|j dkDsJ|j dj jdk7r td|j j|jdt|jsJ|jjy)Nr,rrnrzYBug in Dynamo tracing of exception handling.Top of the block stack is not EXCEPT_HANDLER.re) rLrrrrrr rrrr:)rrrs r POP_EXCEPTz$InstructionTranslatorBase.POP_EXCEPT% s   w & At(() ))    ! ! #t''(1, ,,#((//3CC$D    " IIaLt(() ))    ! ! #rct|jdk\sJ|j}tjdk\r|jd}n|jj}t |t tttfs,tdt|d|dgtjtjdk\r=|j|s,tdt|d |dgtjt |tr |j}n|g}|D]}t |t ttfs,td t|d |dgtj|j|r"t!|j"|j$ry t |t&j st!|j$|j$sy y )Nrr,rnz Exception with bad expected typez"`except ...` has unsupported type rGrzCaught 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)rrrrLrrrHrfr}rrr:rrrrr issubclassrrDr)rexpected_exc_types exc_instanceexpected_types expected_types rcheck_if_exc_matchesz.InstructionTranslatorBase.check_if_exc_matches: s4::!###!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 6rch|jtj|jyr)r8rrhrrs rCHECK_EXC_MATCHz)InstructionTranslatorBase.CHECK_EXC_MATCH s" ),,T-F-F-HIJrcH|js|j|yyr)rrrs rJUMP_IF_NOT_EXC_MATCHz/InstructionTranslatorBase.JUMP_IF_NOT_EXC_MATCH s((* IIdO+rc|jdk(r|j|y|jt|j||j diy)Nzexception matchr)rrr8rr:rs r COMPARE_OPz$InstructionTranslatorBase.COMPARE_OP sD ;;+ +   & II)$++6tTYYq\2N Orcb|jtt|jgiyr)r9rfiterrrs rGET_ITERz"InstructionTranslatorBase.GET_ITER s! ?40488:,CrzjEncountered graph break when attempting to trace CALL_FUNCTION: a call to a regular function, e.g. f(x, y))r8r)c|j|j}|j}|j||iyrr:rrr9)rrrrDs 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 v|jdk(rti}|j}n|jdk(stjdk\r<|j}t |t r ti}|j}n9tdd|jd|jgtjtjdk\r"|j}t |t sJ|j}tjd k\r5tjdkr"|j}t |t sJt ts+|j|rt|j|}t trtj |t"|}t |trt |ts7td d t%|d t%|d gtj&|j)}|j+||j,|y)Nrrrz%Variadic function call with bad flagszflags: zHAttempted to call a variadic function (CALL_FUNCTION_EX) with bad flags rrr,z0Variadic function call with bad args/kwargs typez args type: z, kwargs type: z2Expected args to be a list and kwargs to be a dict)rrmrrLrrrHrr:rrrxhas_force_unpack_var_sequencer}force_unpack_var_sequencerrfcall_custom_dictrr`rkeys_as_python_constantr9r)rr kwargsvarsargsvarsnullrDs rCALL_FUNCTION_EXz*InstructionTranslatorBase.CALL_FUNCTION_EX s ;;! *2.JxxzH [[A !1!1W!<J*l3.r2 xxzH ?!$++/fgkgrgrfst5)445     w &88:DdL1 11 XXZ   w &3+;+;g+E88:DdL1 11   44T:$X%G%G%MNH j"; <(99$jQJ($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|tr|j sJ|j }|dt| |t| d}}tt||}t|t|k(sJ|j|||yr) rr:rrHr}rrrrzipr9)rrargnamesrrD kwargs_listrs rCALL_FUNCTION_KWz*InstructionTranslatorBase.CALL_FUNCTION_KW s 88:yy% XXZ(M2x7R7R7TTT..0 !1CM>2D#h-9I4Jkc(K016{c(m+++ 2tV,rc(|jtj|d|jd}|jd|}t j dkr|j|y|jtj||y)Nrr1rco_namesr,) rrr*rrrLrrr LOAD_METHODrrr4rs rLOAD_METHOD_SUPERz+InstructionTranslatorBase.LOAD_METHOD_SUPER st ;..tA>?kk!n"":.s3   g % OOF #   [00fE Frc|jtj|d|jd}|jd|}|j |y)Nrr1rr)rrr*rrrrs rLOAD_ATTR_SUPERz)InstructionTranslatorBase.LOAD_ATTR_SUPER sK ;..tA>?kk!n"":.s3 rcv|j|j|j}tjdk\r#|j ||j |ytjdk\r#|j ||j |y|j ||j dy)Nrr,)rrrrLrrr8rQrrobjs rrz%InstructionTranslatorBase.LOAD_METHOD s  $hhj   w & IIcN NN4    ( NN4 IIcN IIcN IIdOrc|j|j}|j}|J|j}|j||iyrr)rrrdummyrDs r CALL_METHODz%InstructionTranslatorBase.CALL_METHOD sFyy% }} XXZ 2tR(rc|j}ttj||t j |gi}|j |yr)rrfrr9rhrr8)rattrrrws rrz$InstructionTranslatorBase._load_attr sJhhj )77  "))$/ 0   &rctjdk\r!|jdzr|j|y|j |j y)Nrdr)rLrrr4rrrrs 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\}}ttj||t j |j |giyr)r:rfsetattrr9rhrr)rrr^rs r STORE_ATTRz$InstructionTranslatorBase.STORE_ATTR1 sH 99Q<S ..  "))$++6 <  rc|j}ttj||t j |j giyr)rrfdelattrr9rhrrrs r DELETE_ATTRz%InstructionTranslatorBase.DELETE_ATTR= s>hhj ..  "))$++6 7  rcg}|dksJ|dk(r|jtd|jdk(r tdntd|j}|jtdtd|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. rrerrr1r)extendr+rr(r)rrr_ return_insts rcodegen_return_with_popsz2InstructionTranslatorBase.codegen_return_with_popsE sA~~ > LLQ ({{n, ~ .#N4;;G    *,>y,I; W  rc |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&sJ|j&}t)d|j*} |rlt-j.|t1fdjD}t3|j4t1fd|D}t1fd|D}|jt|j||jtg|D]`}|jt|j|j |j"|z|jgtdb|jtdtdt7| gtdt9|j d d n8t1|j"j;}t1|j4}t<j>d krt7|d k(sJdt7j t7|j@z }jBj*JtEjFjHjJjBj*|j*t1djLD|||t1djLD|t1|jt1|jt1|j@t1|jN }tQjRjHjUdd}|+tWjX|tQjR|d<|jZrj\j_| |d }n=j\j_| tajb|jd| | }jf*jfji|jdd|tjd|jlxxdz 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 __resume_at_c3NK|]}|vr|jvr|ywrr)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| ywrrr/s rrz:InstructionTranslatorBase.create_resume.. s!TQBS=S!!Tr1rrprNTrdrz&variables should not be NULL in < 3.12c3HK|]}|jjywr)r!rrrs rrz:InstructionTranslatorBase.create_resume.. s. s:A!++-:rorig_graphmodulecyrrrrrrz9InstructionTranslatorBase.create_resume.. rrresumesr)7r stack_ctx_argsstack_ctx_idxes_origrrir append_outputr'r r r+rrr(locals_ctx_argsr|rrr/r!r0rr rr)rlocals_null_keysrr#keysrLrrstack_null_idxesrrIlookuprrr rr1 get_contextrKweakrefrefrrinstall_global_unsaferI FunctionTyperAradd_resume_functionrXr)rr resume_instmeta resume_codesris_leafhandle_inactive_ctxjrj_origrjr resume_name all_argnamesr  argnames_nullr4 stack_lennew_codeorig_graphmodule_maybe package_namer0rs` @@rrz'InstructionTranslatorBase.create_resumee slT "%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 (%% %%%,,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 %}%* T,T T* Oc$*?*?&@@ ''..:::#9#@#@ KK KK  $ $ + +    <4+;+;< <    :)9)9: :  $%% & $&& ' $'' ( , -- -!$ *" !9!9$++!F!J!J  " "  " -EL[[&FL $ $X ./A B    KK - -k8 DL KK - -""8T^^[I 'L << # LL , ,$..4l  H,,-2-$$rc d|_t|jj}g}g}g}|}d}|i||ur|} n |j} | j dk7r3|j ||j ||j | |j}|dz }|it|jt|djz } |s{| dk\sJ|jt| dzt| dzD]} |jtd|jtd|j!S|d|ur)|jtd| d} | |d_n|jt| t| dz D]} |jtd|jtdd||dj"} ||dxj"dz c_|dj%t'|jgt)d|j+|d|j-t/| | d g} |D]F}| j1t3|j+||j-gtdH| j1tdtdt|g|j| |jgtdt5j6| tdg}g}t9|D]L\}}|j;||||||||||ud \}}|j ||j |N|j=||||jtd|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. NrrrrrrprT)rr2rr6rrrr rrr@r r+rjr<r(r\rr8rr&rrr#r'r'r8deepcopyr]rr)rrrrtxesidxes resume_instsrrrHcurrent_num_stackrstack_insert_idx filter_instsrJ resume_namesrY resume_coderOs rrz/InstructionTranslatorBase.create_call_resume_at( s6$( t{{** +13*, 6: ~" $55 !!^3 F# S!##K0]]F 1HC   Oc %a ( 9 9/    %) ))   [):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|jDxrl|j xr]|jxs |j xr@|j xr1|j xr"|jjjduS)Nr,rnFc3<K|]}|jywrr%r4s rrzIInstructionTranslatorBase.should_compile_partial_graph..N :A :r)rLrrrr9r r!rrrrrrrcurrent_tracerr )rrs rrz6InstructionTranslatorBase.should_compile_partial_graphE s   w &,,::E$$ D. rhrNTr)rLrrr_is_comprehension_startrr rrrrrrir rv_comprehension_depthrr!_handle_comprehension_graph_breakr_find_comprehension_end_for_ip_comprehension_end_for_ipsr)rr can_speculater% end_for_ips r&_maybe_setup_comprehension_speculationz@InstructionTranslatorBase._maybe_setup_comprehension_speculations sP   G+ q0@++- :)9)9: : :NN" :--- :333 :888  :  **11T9  T[[4 DDFM T66!;..*K!!$'66t<'2D $88: Q ''++J7 !!Q&!rc|j|ry|j|j}|jt |t yN mutation_type)rr:rr8r{rarqs rrpz$InstructionTranslatorBase.BUILD_LIST s<  6 6t <  $++& ,u4D4FGHrctjrtdddg|j|j}t |t }|j|y)Nzmissing BUILD_SET handlerrz:Missing BUILD_SET bytecode handler (for testing purposes).rr)r+inject_BUILD_SET_unimplemented_TESTING_ONLYr:r:rrnrar8)rrrnew_sets r BUILD_SETz#InstructionTranslatorBase.BUILD_SET sO  = = 3X    $++&e3C3EF 'rc D|j|j}g}|D]#} |j|j|%|j||ty#t$r.t dt ||dgtjY~wxYw)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:rr'rNotImplementedErrorr:rrrr8ra)rrrseqsrseqs rBUILD_LIST_UNPACKz+InstructionTranslatorBase.BUILD_LIST_UNPACK syy% C  S::4@A  #e+;+=>?' KH#&%(2!29-889  s A((4BBc2|j|ty)Nr )rr}rs rBUILD_TUPLE_UNPACKz,InstructionTranslatorBase.BUILD_TUPLE_UNPACK s t7rc |j|ry|j|jdz}tt |ddd|ddd}|j t |ty)Nrrr)rr:rrr r8rmra)rrrds r BUILD_MAPz#InstructionTranslatorBase.BUILD_MAP sd  6 6t <  $++/* U3Q3Zqt!t- . #A5E5GHIrcT|j|j}|Dcgc]#}ttj ||gi%}}i}|D]/}t |t sJ|j|j1|jt |tycc}wr) r:rrfrr9rHrmupdaterr8ra)rrrrTrws rBUILD_MAP_UNPACKz*InstructionTranslatorBase.BUILD_MAP_UNPACK s $++&MRS&44TA3CSS!# #Aa!23 33 MM!'' " # .0  Ts(B%c d|j}|j|j}t|tsJ|j sJ|j |}t|t|k(sJ|jttt||tyr) rr:rrHr}rrrr8rmrr ra)rrr?rs rBUILD_CONST_KEY_MAPz-InstructionTranslatorBase.BUILD_CONST_KEY_MAP sxxz4;;'$ ...&&(((--d34yCK''' Sv&'.0  rc |jd\}}|jdkDsJ|jJ|j|j j }t |t sJ|j|d||fiy)Nrrrk)r:rr4rrrHrmr)rrrrrs rMAP_ADDz!InstructionTranslatorBase.MAP_ADD swyy|1{{Qxx###jj$((#++-#0111 maVR8rc|j}|jdkDsJ|jJ|j|j }t |t sJ|j sJ|j|d|giy)Nrrrrr4rrHrn is_mutablerrrrrs rSET_ADDz!InstructionTranslatorBase.SET_ADD su HHJ{{Qxx###jj$((##{+++~~ eaS"-rc|j}|jdkDsJ|jJ|j|j }t |t sJ|j sJ|j|d|giyNrrrrs r SET_UPDATEz$InstructionTranslatorBase.SET_UPDATE su HHJ{{Qxx###jj$((##{+++~~ hR0rcz|j}|jdkDsJ|jJ|j|j j }t |t sJ|jsJ|jjj||jj|yr) rrr4rrrHr{rrr.mutationrrrs rrz%InstructionTranslatorBase.LIST_APPENDs HHJ{{Qxx###jj$((#++-#|,,,~~   ))#. rc b|j}tjdkr|j}|j}tjdk\rBt |j dsJt j|j j}d}d}d}d}tjdkrV|T|dzr|j}|dzr|j}|dzr|j}|dzr|j}|jt||j||||y) Nr, co_qualnamerrrrr) r4rLrrrr(rrhrrr8rrrA) rrflagsfn_namerddefaultsclosurer kwdefaultss r MAKE_FUNCTIONz'InstructionTranslatorBase.MAKE_FUNCTION s    g %hhjGxxz   w &4::}5 55&--DJJ4J4JKG    g % 4<"hhjG4<"&((*K4|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_functionjs0  $ $ =6^   %rcF|jdk(r|j|yy)NGRAPH_BREAK_IF_LEAF)rrrs rrzInstructionTranslatorBase.NOPys" ;;/ /  - -d 3 0rc$|jyrrrs rrz!InstructionTranslatorBase.POP_TOP~   rc|j}|j}|j||j|yrrr8rrars 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)rrrrrrs rROT_FOURz"InstructionTranslatorBase.ROT_FOURsZ HHJ HHJ HHJ HHJ !  !  !  ! rch|j}|j||j|yrr)rrrs rrz!InstructionTranslatorBase.DUP_TOPs# HHJ !  ! rc|j}|j}|j||j||j||j|yrrrs r DUP_TOP_TWOz%InstructionTranslatorBase.DUP_TOP_TWOsD HHJ HHJ !  !  !  ! rc|dk(r!ttj||giS|dk(r!ttj||giS|dk(r!ttj||giS|S)Nrrre)rfrr9rascii)rrflags r_convert_valuez(InstructionTranslatorBase._convert_valuesp 19"3'55dUGRH H QY"4(66teWbI I QY"5)77ugrJ J rc|j}t|tr?ddlm}m}|j ||||j}|j|y|j||dz}tj d|jzdz}|jttj||giy)Nr)LazySymNodeFormatStringrwryrez{:})rrHrtorch._dynamo.variables.lazyrrwrrr8rrhrr9rfrformat)rfmt_specrrrrwfmt_vars r _format_valuez'InstructionTranslatorBase._format_values  e_ -  /'..'x8E IIe  ##E54<8"))$1L1L1N*NQT*TU ?3::6%8H"Mrc|j}|J|dzdk(r|j}ntjd}|j ||S)Nrr)r4rrhrr)rrrrs r FORMAT_VALUEz&InstructionTranslatorBase.FORMAT_VALUEsQ   DLT !xxzH'..r2H!!(E22rc \g}g}i}|jJ|j|jD]:}|jr#|jd|j|7t |t j r|j|j|j|jt|jt|jjzr2tdd|d|d|jdgtj|j!|jtdt#|d gtj=|j%t j j'd j)|||y) 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)r4r:rrrHrStringFormatVariable format_stringr'sym_argsrr? sym_kwargsr:rrrrr8rr)rrformat_string_partsrrparts r BUILD_STRINGz&InstructionTranslatorBase.BUILD_STRINGsu)+&(-/xx###IIdhh' 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(sJ|jdk(rd}nd}td|}|j|y)Nrriszis notrr1)rr(r)rr new_argvalnew_insts rIS_OPzInstructionTranslatorBase.IS_OPsM{{a4;;!#333 ;;! J!J%l:F !rc |jdk(s|jdk(sJ|jd\}}|j} |j|j|d|gi|dk(r|j|yy#tj t f$rs}t|t r|jr|j|j|jtj|t||giYd}~d}~wwxYw)Nrrr __contains__)rr:r8rrObservedTypeErrorr;rHr!rrrbrGrB UNARY_NOT)rrleftrightrOr&s r CONTAINS_OPz%InstructionTranslatorBase.CONTAINS_OPs{{a4;;!#333iil e [[  IIe''ntfbI J* 7 NN4  %  ! !    $ ,??&&( II00#))$0IJ5M   s$A>>D A)DD c|j}|jdkDsJ|jJ|j|j }t |t sJ|j sJ|j|d|giy)Nrr')rrr4rrHr{rrrs rraz%InstructionTranslatorBase.LIST_EXTENDsu HHJ{{Qxx###jj$((##|,,,~~ hR0rc|jttj||j giyr)r8rfr)r9rrs r LIST_TO_TUPLEz'InstructionTranslatorBase.LIST_TO_TUPLEs* /%(66tdhhj\2NOrcd|jd}|j|sJ|jtur|t j t j|tdgi}|j|td||j|td|||jd<yy)Nrnzgenerator raised StopIterationrfr) rrrrrrfrr9rhr)rrr^new_vals rSTOPITERATION_ERRORz-InstructionTranslatorBase.STOPITERATION_ERROR s jjn))#... <<= (// =KK!"BCDG  '7 'F L  '7 'Dc J$DJJrN )rc$|j}|jdkDsJ|jJ|j|j j }t |t sJ|jsJ|j|d|giyr) rrr4rrrHrmrrrs r DICT_MERGEz$InstructionTranslatorBase.DICT_MERGE2s HHJ{{Qxx###jj$((#++-#0111~~ hR0rc$|jyrrrs r GEN_STARTz#InstructionTranslatorBase.GEN_START=rrc|jd}|jr<|jtjt |j y|j|j|dgiy)Nrnr)rrr8rhrrrrrs rGET_LENz!InstructionTranslatorBase.GET_LEN@s\jjn  ! ! # II&--c#2H2H2J.KL M IIcoodIr2> ?rc|jd}|j|jtj|t |giy)zr If STACK[-1] is an instance of collections.abc.Mapping, push True. Otherwise, push False rnN)rr8rrbrGrCrs r MATCH_MAPPINGz'InstructionTranslatorBase.MATCH_MAPPINGGsC jjn  , ,%%dO<  rc|jd}|j|jtj|t |giyNrn)rr8rrbrGrFrs rMATCH_SEQUENCEz(InstructionTranslatorBase.MATCH_SEQUENCEUsBjjn  , ,%%d,?@  rc |jd\}}}tj|j}|j |j t j|t||||gitjdkrC|jd}|j tjt|t yy)Nrer,rn) r:rhrr4r8rrbrGrDrLrrrr])rrsubjectrnamesr4rs r MATCH_CLASSz%InstructionTranslatorBase.MATCH_CLASS_s"iile%%dhh/  , ,%%d,<=#sE*     g %**R.C II&--&>N2O.OP Q &rc|jd}|jd}t|tsJ|j|j t j |t||gitjdkrC|jd}|jtjt|t yy)Nrnrr,) rrHr}r8rrbrGrErLrrrhrr])rrr?rrs r MATCH_KEYSz$InstructionTranslatorBase.MATCH_KEYSoszz"~jjn$ ...  , ,%%dON2O.OP Q &rcD|j|jdy)Nrr8rrs rLOAD_ASSERTION_ERRORz.InstructionTranslatorBase.LOAD_ASSERTION_ERRORs $//0@ABrcD|j|jdy)N__build_class__rrs rLOAD_BUILD_CLASSz*InstructionTranslatorBase.LOAD_BUILD_CLASSs $//0ABCrz`Encountered graph break when attempting to trace BINARY_SUBSCR: a binary subscript, e.g. x[attr]cp|jdk(r|j|d|_y|jrJy)NrF)r4append_prefix_instrrs rRESUMEz InstructionTranslatorBase.RESUMEs5 88q=  # #D )&+D #.. ...rcP|jJt|j||Sr)r4_binary_op_lookuprs r BINARY_OPz#InstructionTranslatorBase.BINARY_OPs(88' ''$TXX.tT: :rcyrrrs rr/z!InstructionTranslatorBase.PRECALL rc|jd|j}t|tsJ|D]}t|trJ|j Jt j||_y)N co_constsr)rr4rHr)rr7rhr)rrr7rs rr0z"InstructionTranslatorBase.KW_NAMESsl$$[1$((;(E*** )DdC( (( )}}$$$(//h? rc6|jtyr)r8rrs rrQz#InstructionTranslatorBase.PUSH_NULLs ,.!rc|rXtjdk\sJ|j}t|tr|j sJ|j }n$|jr|jjnd}|jJ|j|jdz}tjdk\r!|d}t|dtrgn|dg}n&t|dtr|d}g}n |d}|dg}|rO||dt| z}|t| d}tt||}t|t|k(s J||ddz}i} |j|||d|_y#d|_wxYw)Nrrrrr)rLrrrrHr}rrr7rr4r:rrrr r9) rrcall_kwr7contentsrDrr rs r_callzInstructionTranslatorBase._calls~ ##w. ..xxzHh 68;V;V;X XX224H.2mmt}}**Hxx###99TXX\*   w &!B#HQK>2Xa[MD(1+|4a[a[  } (1H ~66D"CM>#34K#h 45Fv;#h-/ //(12,&DF !   r4 0 DMDDMs !E<< FzTEncountered graph break when attempting to trace CALL: a function call, e.g. f(x, y)c&|j|yrrrs rr.zInstructionTranslatorBase.CALLs 4rcr|jJ|j|j|j yr)r4r8rrs rCOPYzInstructionTranslatorBase.COPYs-xx### $**dhhY'(rc|jJ|j|j |jdc|jd<|j|j <yr)r4rrs rSWAPzInstructionTranslatorBase.SWAPsMxx###04 DHH90EtzzRT~- 2 DHH9-rcyrrrs rCACHEzInstructionTranslatorBase.CACHErrc&|j|yrrrs r BEFORE_WITHz%InstructionTranslatorBase.BEFORE_WITHrrc  t|tr+|js|jj |t j dk\r|jr>|jr/|jj|jdjurd}nE|jjJ|jjj}n |j}|rt|tstjr;|jj t||t|j |n9|jj t||t|j |j#|S)Nr,rn)rHrjsupports_graph_breaksrrrLrrr9r r!rr>rrr rrenter)rrjrr!s r enter_ctxz#InstructionTranslatorBase.enter_ctxs( s: ;--/  0 0 7 7 <   w & !!$$%%,,D4D4DR4H4O4OO,,::FFF..<<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)rjs runsupported_ctx_graph_breakz5InstructionTranslatorBase.unsupported_ctx_graph_break:s31GuM?@T@T@V?WWij rc.|j}t|ttfs|j |t|ttfsJ|j t ||j|j |j||yr) rrHrirjr*r8rlr!r()rrrjs rrz.InstructionTranslatorBase.setup_or_before_withKshhj )+IJ   , ,S 1 )+IJ    *3 <= $..d+,rcV|jsJ|jj|yr)rrrrs rr z,InstructionTranslatorBase.append_prefix_instZs%&&&&   &rc.tjdk\rq|jset|j|j t sJ|jjj|j|j <y|j|yr) rLrrrrHr|rrrr.track_cell_newr rs r MAKE_CELLz#InstructionTranslatorBase.MAKE_CELL^ss   w &t/F/Fd224;;?N NN ((779   -  # #D )rc&|j|yrr rs rCOPY_FREE_VARSz(InstructionTranslatorBase.COPY_FREE_VARSi %rc&|j|yrr1rs rRETURN_GENERATORz*InstructionTranslatorBase.RETURN_GENERATORlr3rc2tjdk\r|jn|jdtjdk\rO|j|}||j vr1|j j ||xjdzc_yyy)Nrrrdr)rLrrrr:rr}discardrz)rr current_ips rrz!InstructionTranslatorBase.END_FORss   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]r|rKrrr:rrr,rs rLOAD_FAST_CHECKz)InstructionTranslatorBase.LOAD_FAST_CHECKs` $&&**4;;=| L C Mdkk][5)445   trc|j|jvr|jtn|j |t|j|j<yr)rr|r8rr,rs rroz-InstructionTranslatorBase.LOAD_FAST_AND_CLEARsD ;;d22 2 IIln % NN4 ,8NT[[)rc|jtj|d|jJ|jdzr|j |y|j |j y)Nrr1r)rrr*r4rrrrs rLOAD_SUPER_ATTRz)InstructionTranslatorBase.LOAD_SUPER_ATTRsV ;..tA>?xx### 88a<   T " OODKK (rc|jdk(r|j|y|jdk(r|j|y|jdk(r8|jt |j j |ytdd|jd|jdgtjy) Nrerz Missing CALL_INTRINSIC_1 handlerzCALL_INTRINSIC_1 operand: z,No handler implemented for CALL_INTRINSIC_1 z instruction.r) rrUNARY_POSITIVEr8r}rrr:rrErs rCALL_INTRINSIC_1z*InstructionTranslatorBase.CALL_INTRINSIC_1s ;;!   $ $T * [[A     % [[A  IImDHHJ$H$H$NO P :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)rrrs rCALL_KWz!InstructionTranslatorBase.CALL_KWs 4 &rc8|jjdvsJy)N)POP_JUMP_IF_TRUEPOP_JUMP_IF_FALSEr)rrrs rrz!InstructionTranslatorBase.TO_BOOLs'$$++0    rc J|j}|J|j}t|tsJ|j}|dzrDtj dk\sJ|j |tjdgi}||_ n|dzr||_ nz|dzr\t|tsJ|j}ttt|ddd|ddddt! }||_ n|dzr||_n |dzr||_|j'|y) NrrrrrT)strictr)r4rrHrrrLrrr9rhrrrr}rrmrr rarrr8)rrrrDrranns rSET_FUNCTION_ATTRIBUTEz0InstructionTranslatorBase.SET_FUNCTION_ATTRIBUTEs   XXZ"8999xxz 4<##w. ..%%d-=-D-DQ-G,H"MD!BN T\BJ T\dM2 22JJE#SssU14a4[>?.0C!BN T\ BM T\BK " rcv|j|j|j|jyr)r8rrrrs r CONVERT_VALUEz'InstructionTranslatorBase.CONVERT_VALUEs% $%%dhhj$++>?rcN|jtjddy)Nrr)rrhrrs r FORMAT_SIMPLEz'InstructionTranslatorBase.FORMAT_SIMPLEs +2226:rcD|j|jdyr)rrrs rFORMAT_WITH_SPECz*InstructionTranslatorBase.FORMAT_WITH_SPECs 488:q)r) __enter____exit__ __aenter__ __aexit__c`t|jtsJd|j|j}|dvr|j }t|t t fs|j|t|t t fsJ|dk(r,|jt||j|y|jt|d|j|y|j||j }|j||j|y)Nz*expected LOAD_SPECIAL arg to be set to int)rTrUrT) rHr4r_load_special_namesrrirjr*r8rkrQrlr)rrrrjrs r LOAD_SPECIALz&InstructionTranslatorBase.LOAD_SPECIALs$((C(V*VV(''1 , ,((*C-/MN005-/MN {" 3C89t$ 23=>t$ OOD !((*C IIcN NN4 rc`|jtj|jyr)r8rhrrrs rLOAD_SMALL_INTz(InstructionTranslatorBase.LOAD_SMALL_INTs "))$++67r)rrr)ranyct|jtsJd|j|j |j |jy)Nz2expected LOAD_COMMON_CONSTANT arg to be set to int)rHr4rr8r_common_constantsrs rLOAD_COMMON_CONSTANTz.InstructionTranslatorBase.LOAD_COMMON_CONSTANT)sH$((C( @ ( $//0F0Ftxx0PQRrcP|jjdkDr d|_yy)NrcyNTrrrrrz>InstructionTranslatorBase.is_non_empty_graph..2r8rTF)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_summary6sN # *&( #ww  ! !##%&h7N.O)PP   rc tjt|jdd|jt|jdddS)Nr rF) lookup_line)rf FrameSummaryrrrrs rrz'InstructionTranslatorBase.frame_summaryAs?%% DKK < KK DKKK 8   rct|jdd}tjd}|j |duS)Nrrkz.*torch/nn/modules.*)rrrecompilematch)rrnn_modules_patterns ris_co_filename_from_nn_modulesz8InstructionTranslatorBase.is_co_filename_from_nn_modulesIs:4;; {CZZ(?@!''1==rc|jj|tj|}t t |j tj|Sr) rinstall_global_by_idrCrDr>rPrr= WEAKREF_ALIVE)rrr global_names rstore_global_weakref_by_idz4InstructionTranslatorBase.store_global_weakref_by_idNsJkk66vw{{5?QR   , 7 7 8R8R S rcB|jjjSr)rtracing_context fake_moders rr{z#InstructionTranslatorBase.fake_modeUs{{**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_modeYs3%% ( * $)D !ED !s/#/ ,/c|jJ|jdkDsJ|jj|jj|j |jdz |j |jdz Sre)rrrrrrrrs rrz#InstructionTranslatorBase.speculategs|''333''!+++##(( KK # # KK  $ $q (   d66: ;   rctjdk\sJ|jJ|jdz }t}|j|t |z |Dcgc]}|j }}||k(Scc}w)zDetect if we're at the start of a list/dict comprehension in 3.12+. In Python 3.12+, comprehensions are inlined with a bytecode pattern that precedes BUILD_LIST/BUILD_MAP. rdr)rLrrrrtrrr)rrpatternrrs rryz1InstructionTranslatorBase._is_comprehension_startqs 7***''333  % % )46*.*;*;BW.s2   #**j8  s(+rrr,cB|}|dk(xr|dk(xs|d S)Nrrr)rpatpatternsrrs rmatcheszAInstructionTranslatorBase._analyze_comprehension..matchess=4.C C$88_!55QS=Q9Q rrFrrrrrTz)Comprehension analysis failed: No matcheszpre_store_ops=z, post_store_op=z8Comprehension does not match any known bytecode pattern.)rrrrrr)rrrr)rLrrrrrrrinsertrrr|r:rrjr4rrrXrHr)rr)rstart_iprrrdefined_inside iter_scan_iprr for_iter_ipbody_ip next_instvar_name var_namesscan_ip store_fast_iprrrrrrs` @@@r_analyze_comprehensionz0InstructionTranslatorBase._analyze_comprehensions>7***''33357++a/#% !# #% #&5 !| a$$\2D{{33$$Q 4!  44! a m,88:   C[   8Z0  [1_j9 7G$$W-D{{f$Q7Q;;S --gk: ##|3(//H}49T#**84&**84{{l*""4;;/'' 4#-dkk5#ADKK ~!*7H~5(-:W%,,X67+ 74$& q. c$++, ,!!'*11\A  !2!27!;!B!B C qLG c$++, ,!!'*11\A   c$++, ,!!'*11\A qLG c$++, ,!!'*11\A T..//   g & - -    %) 8 **=9@@J#O [ !J#O%-k%:?%KgkQXG J  4_ EEJ"O C(7G WV  %!+'#'  rc `tjdk\sJ|j}|jjj t r.|jr"tdt|jdg|jJ|jdz }dt|jz}td|jg}tj!d|j"j%||| }t'|Dcgc]8}t)|j*t|j*|z |zt,:}}|j/||d } t1|j"j2} t5d |D} t|j*t| j6z } | j9gt;| |zdz| j=d | j?tAt'|D]^}| j9tCd ||r | j9| jEB| j9tGd dg`| j9tGdg|jI||||| | \} }| j9gt;| d z| j=d | j?tGddt;| d z| j=d | j?tGdd|jK| g|g| | d kDr| dzdz}| j9gt;|| j=d | j?tM| j=| | j=dtGdd tGdtGd|jN|jPr |jPgngz}i}|D]\}tS|jT|<|| jVvr| jV|||<;t| jV| jV|<^| d z}|jNr1| j9gt;|| j=d | j?tY|jND]\}}| j9gt;d | j=|dz| j?||vr<| j9gt;d | j=||tGd| j9tGd dg| j9tGd| j=d | j?g|jZr|j]tSn|jPr| j9gt;|| j=d | j?|jP|vr9| j9| j=||jPtGdgnP| j9gtCd tGd dtGdn| j9tGdg|j"j_| ja|jb|jd}|j"j_|jg||d|_ ycc}w)zHandle list/dict comprehension graph break. Builds a synthetic function wrapping the comprehension bytecode, calls it via codegen_call_resume, then chains into the resume function for the post-comprehension code. rdzDComprehension graph break in resume function with captured variableszCannot use comprehension optimization inside a resume function when there are captured variables. This can cause issues with deeply nested source chains.rNrcomprehension_graph_breakzcomprehension triggered compilerrc3&K|] }|rd yw)rNr)rms rrzNInstructionTranslatorBase._handle_comprehension_graph_break..GsE!1AEsrrrrrprtrr)4rLrrrrrrXrLrr:rrrrr?rrrrrrjrHrrr:r2r6rr@r r&rrrr+pop_nullr(_build_comprehension_fnrr'rrrr|rr]rr8rr\rrr)rranalysisrrrrrYstack_pops_null_maskrIr nonnull_countlive_stack_depthrSrframe_values_pos vars_to_pass existing_varsrfv_depthrM walrus_varrHs rr{z;InstructionTranslatorBase._handle_comprehension_graph_breaks7***..0 ;;   ) )*G H%%b 6 67!8 ''333++a/X3344 #$?$BTBTBVAWX 34%)KK$@$@ !%A% !:&  tzz#djj/J">"BC\ R  *(+ t{{** + E';EE tzz?S1F1F-GG  - :Q>? $$Q' '')   % +, MA   [^ ,#A&  /  "4]"J!KL  M ,Y789 !88       '  -12 $$Q' '') #D  *4,,,*.*;*;H*E h'.1$2C2C.D!!(+  E$a'       *((+++- "+8+?+?!@ Q :  $Q,,QU3//1.$$(^00z1JK/~>$$&8A&N%OP' Q*   &y1((+++-    # # IIo' (     *((+++- ""m3  ,,]8;N;N-OP*>:  $Q*=a@+95   0;< = ++B,?,?,AB''8  ++  & &{4M N $( } s =\+cddlm}ddlm}ddlmmtfd|jD} ddgt| ztD cgc]} d|  c} ztttjjxsgtjjxsgzj jnjj t#d jj$d j&j(zj*r j*gngzj,z d f d } |j| \} } || | jr j.j1| | fSj.j1t3j4| j6| fScc} w) aBuild a synthetic function wrapping comprehension bytecode. Uses the same calling convention as resume functions created by create_resume / ContinueExecutionCache.generate: the first two args are __nested_resume_fns and __nested_frame_values (ignored here), followed by stack items and live locals. Returns (code, name) where name is the global name for the function. r)transform_code_objectr) CO_VARARGSCO_VARKEYWORDSc3HK|]}|jvs|ywrr-)rrrs rrzDInstructionTranslatorBase._build_comprehension_fn..s& AT5K5K5M,MA s""__nested_resume_fns__nested_frame_values___stack__comprehension__at_c L |d<tjdk\r|d<|d<d|d<|d<t |d<d |d <d |d <t Dcgc] }| vs| c}z|d <|d  zz|d <g}r%|j t dt|j t dd dz }t D]F}|r|j t d#|j t dd||dz}Hj j}g} jsO jr'|j t d jn|j t dd jr_ jD]}|j t d| |j t ddt jz|j t d||z|z|ddycc}w)Nrr,rco_firstlinenorrr co_argcountrco_posonlyargcountco_kwonlyargcount co_varnamesco_flagsr2rrrrQr,rr1rrrr) rLrrrr)rr(rj_copy_comprehension_bytecoderrrr)rrrr nonnull_irY comp_instsepiloguerrrrrcomprehension_body_varsrrrrrrrrs rrzAInstructionTranslatorBase._build_comprehension_fn..update-s?'.L #7*.5 ]+-3L) **,L '*2L '*-d)L '12L- .01L, -*/#:LaatmLL+L '(4J'?^+C(L $)+F 01As8}UV MM,X1= >&)I:& #'*MM"4["ABMM*;)?UVNI #::8X__UJ+-H++&&OO*;x?R?RSOO$6|D$QR## ( 4 4VHOO$6{8$TUV&%H$8$8 99 OO.~> ?$z1HVaZo. .&!!rcdg}tjrs|j}|e|j|jj |j |jj}|j||j}|e|j|j|t|Sr) rrr rrrrrrreverser))r frame_locframe_loc_chain_list current_txparent_frame_locs r_get_frame_loc_chainz.InstructionTranslatorBase._get_frame_loc_chains79  % %>BkkJ(#'#7#7%%11%%%%44$ %++,<='.. ( $$&##I.)**rc |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/||}d|dd|d d |d  t j"r |d | d z n t1| z tj2j5dd fdt7|t8r |j:n t=|} t>jAtBjDrptFsjtIjJ| |frSt j"r& dz dj'|jLdzz t>jO d|_yt>jOd|d|d |d|_y#t$r|d|df}YwxYw)Nr#rnrrrrzGraph 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. artifactc dddS)Ndynamo_graph_break_reasonstring)rencodingrrrrrz;InstructionTranslatorBase.log_graph_break..s3$!rc6dtjS)Nr)rf format_exc)user_stack_tracesrrz;InstructionTranslatorBase.log_graph_break..s"2!32i6J6J6L5MNr) 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)(loggedrrrrrrrr rrrrrr IndexErrorrrr7rrfrgr5r3r_loggingtrace_structuredrHr;rrgraph_break_log isEnabledForrDEBUGexplainr\rrr) rrrr user_stackrframe_loc_chainstack_above_dynamo_formattedstack_above_dynamouser_stack_formattedrrs @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! !    c ]+-.I sBJ44K  K c^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)rrrrrr!)r:r6rr )rdrs rrz0InstructionTranslatorBase.raise_loop_graph_breaks9)%&7&=%>?hD%CCD rct|||_||_||_||_||_| |_| |_d|_ g|_ d|_ d|_ td|_d|_g|_g|_d|_d|_d|_g|_||_t/d|_d|_t5|_||_||nt;|j8|_||_||_ ||_!||_"| |_#||_$|$tJjLrtO| |||_(nd|_(i|_)i|_*| |_+d|_,d|_-d|_.d|_/d|_0d|_1d|_2d|_3g|_4||_5d d l6m7}m8}m9}m:}| jv||z|z|zzr|jyt{d| |_>d|_?dgt| jz|_Btjtj|_Gtjtj|_Itj| j|y) NrrTrn)maxlen)rdrrFr)CO_ASYNC_GENERATOR CO_COROUTINE CO_GENERATORCO_ITERABLE_COROUTINE)MrHrIrdistributed_staterr|r}r~rrrrrr(rrr rrr7rrrrrrzrr}rrrr&rArCrrrrreplay_record_enabledrHrnn_module_stack num_callsexportrrrrrrr rrrrrrrrrr8rfrrrrr=rrrrrrrr lazycacher)rrrr&rArCrr|r}r~rrrrrrrrrrrrrrrPs rrIz"InstructionTranslatorBase.__init__#s0 .!2 . 0-J*%:"-1),. #$ #5e#< (,%UW,  "&(%*"%5"$%!47E'0<*G DUnion[ContextWrappingVariable, GenericContextWrappingVariable]rr-rrb)rjrbrr)rhzOptional[list[Any]]rr)rztraceback.FrameSummary)rrrrrrrzOptional[FakeTensorMode])r}z!Callable[[VariableTracker], bool]rr)rrr)rr)rrrrrrrz list[bool]rrrIrArr)rrrrrr)rrrrrrrtuple[str, int])rrrztuple[tuple[str, int], ...])rrrrrzUnsupported | StepUnsupportedrr)rdtypes.CodeTyperr;rr)NNN)(rr@rrr&rrArrCrrrr|r{r}r{r~rrrrrrrrrrrrrTrOptional[DistributedState]rzOptional[tuple[types.CellType]]rrrz Optional[dict[Instruction, int]]rr(rrrrrrrrrrr9rrrrrrrLrrrpropertyrrrrr8rrr:r,r2rr7r; LOAD_CLOSUREr>rrIrBcached_propertyrOrRrXrrKrlrurEAGER_IMPORT_NAMErrrEr JUMP_FORWARD JUMP_ABSOLUTErrnot_rHrrGJUMP_IF_FALSE_OR_POPJUMP_IF_TRUE_OR_POPrrrrrrrrrrrrrZrrrrrrrrrrrrr?rr rrrrrrrr"r% staticmethodr)rrrrrrrrrtrvrrprr{rrBUILD_TUPLE_UNPACK_WITH_CALLrrBUILD_MAP_UNPACK_WITH_CALLrrrrrrrrrrrrrrrrrrrrrrrarrr DICT_UPDATErrrrrrrr rErr@negUNARY_NEGATIVErinvert UNARY_INVERTpow BINARY_POWERmulBINARY_MULTIPLYmatmulBINARY_MATRIX_MULTIPLYfloordivBINARY_FLOOR_DIVIDEtruedivBINARY_TRUE_DIVIDErN 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_ORrrr/r0rQrr.rr rJUMP_BACKWARD_NO_INTERRUPTPOP_JUMP_FORWARD_IF_TRUEPOP_JUMP_BACKWARD_IF_TRUEPOP_JUMP_FORWARD_IF_FALSEPOP_JUMP_BACKWARD_IF_FALSEr"r$r(r*rr r/r2r5rr:ror=rArCrErrMrOrQrSLOAD_FAST_BORROWrPOP_ITERrYrZr\r_r`rrirrsrxr{ contextlibcontextmanagerrrryr|rr{rrrrrrrIrQrRs@rrrs(  //00#==.."FF  &&$$""&& K((####33  ..AA //! EE %%%%.!F00'  8 8$8+ 8  8, 4 $ 4( 4+ 4  4 U $ U( U+ U Un Wob 7"* +\ ;;BH2 H=T  ;!+FV2./L *J*JJ !E(##, 2:;|$% 66,>4LM$X]]E:#HNNE:' t<&x~~t<U U (UN* (- ^ RD 0..$)LA'F<:$*QfKP D ) )  >; >;@ A -  -G  )% A   &) >A% A%!A%" A% + A%  A%A%"A% $A%Fg%g%$=g%  g%Rq?*q?:Cq?IRq? q?q?f & ~= =8(1!FI @L@ 8$6 J  "2 9.1% N@0 N  4   N(3 B"!:1P%$1K@   R R"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/ 7" ; @"-!^ i )VM!%+HNNEB ,X^^U C ,X]]E B!-hmmU!C (# K##  #J  -' *&& /;)$ A '  ' B@;*!IH !88S >B  ':     > 55 *9 *  * * !  A Fd(L~!'~!~! ~! ) ~!  ~!"~! $~!@%( (""%2"EH" "+(+ $+(l$ll+ l  l\    <48,048-@;@;(@;! @; " @; # @;%@;4@;5@;(B@; 3@;@;@;@;(@; %!@;"6#@;&1'@;(*)@;,2-@;. /@;@;r) metaclassceZdZed dZej d dZ d fd ZddZ ddZ ddZ ddZ ddZ dd Zdd ZxZS)r>c"tjSr)tlsrrrrrz InstructionTranslator.current_txs ~~rc#Kttdd}|t_ d|t_y#|t_wxYww)Nr)rrUr)rr~s rset_current_txz$InstructionTranslator.set_current_txs1\40 # "CNUCNsA0 A =Acttjd|jd|dd|dt|t || || | | ||||| | ||||||iidd|| d|||||jt|jj5|j5| |_ | |_ |jr|jsJd i|_t|j!}t#j$|j'd d}|j)D]h\}}||vs d}|r)t+|j'|ij)}t-j.|t1|d | }||j|<j|jj2}|j5D]x}||vrL||}t1|d d }t-j.||}|j7}|j9||n|j7}||_||j|<z|Jt=|j?|D]g\}}tA|}t1|d } t-j.|jB|}|jK|||}||_||j|<itM||_'tQ|_)| r.tFj,jU|j|_ddddddy#tD$rtGjH}YwxYw#1swY5xYw#1swYyxYw)Nztorchdynamo start tracing rrrr) local_scopercrtorch_function_mode_stackrrr)rrr&rArCrrr|r}r~rrrrrrrrz4Export without one graph - something has gone wrong.dynamismT)is_inputr[)r\is_derefed_cell_contents)r])+rrINFOrrHrIr@_throw_if_in_functorchrrrzrWrrr|rrr1rBrKr frozensetrwrrRr.rr.r9r:r rrQ cell_contentsrrDeletedVariabletrack_cell_existingrr~rr realize_all)rrrr&rArCrrZr compiler_fnrrexport_constraints frame_staterrrrrr[rrlocal_dynamismvarr.contents_sourcer1cell_varr0 cell_sourcerPs rrIzInstructionTranslator.__init__s(   LL((8,}:U9VVWXdeuXvWw x  "$&*C# &!%*."&+%/A ! F ##%T[[00 1d 43F3F3Hd #,DN DK{{~~J~$&D *-d.D.D.F*G #//7;;JMH'~~/ 5 e00%)N)28<<b3I3O3O3Q)R-44# %)%3C25D((. 5" ;;33L % 68#$TNE*'2!%15'O 5H4N4N5L ,::D &(1'D'D'P'P((($Ed d d `"?#,#<#<#>L?ad d d d sQM0B M >D=M < L'A:M M'M M M M  M MMctjjd}tj|j j d|j j }tjjj}tjjjjtjjjjtjjjjf}|\|j|vrI||urD|jjj!}d|d|d|d}t#dd|g yyyy) NeagerrezhIf you are reaching here, it means dynamo failed for one of the following reasons: - Calling torch.func.zP(compiled_fn) function from eager mode is not supported. Ensure that torch.func.zp is also wrapped within a torch.compile function. For more information, see PyTorch issue #128711. - torch.func.z2(fn) requires the function to be inlined by dynamoz%Unsupported functorch tracing attemptrr)r_dynamolookup_backendr?getattr_staticrre_C _functorchpeek_interpreter_stack TransformTypeVmapGradJvprmrlowerr:)rrnreciforbidden_keysrrRs rr_z,InstructionTranslator._throw_if_in_functorchYs0 ,,W5,, KK # #]DKK4K4K XX 7 7 9 HH   - - 2 2 HH   - - 2 2 HH   - - 1 1  >bffh.8[PU=U668==&&(D((,v.**.0 !%v%W Y  ?  >V8>rct|tr|j|jSt|tr|j |j Str)rHrRr&r:rOrArwr))rrs rget_example_valuez'InstructionTranslator.get_example_valuexsE fk *==!2!23 3 fl +>>&"4"45 5rc|jjD]G}t|tst |j t jjsGyyr) r|rrHrrrrnnModule)rrs r$symbolic_locals_contain_module_classz:InstructionTranslator.symbolic_locals_contain_module_classsR%%,,. A!56:$$&<   rct|jrU|jdx}rCt|tr2t |j |t |jd<yyyy)Nrnr)rrrHrqrzrra)rrs r"replace_tos_if_return_is_generatorz8InstructionTranslator.replace_tos_if_return_is_generators`  O 2&&3 <=1--d3.0DJJrN>' rc|j|jJ|jJtj d|j|jz t j s|jjdk(rw|jsk|js[|jsO|jsC|js7|js+tj dt#|j$d|_t't(j*d|j$j,d|j.dt0j3d|jj5|t7d|j9gd |j.d k(rd nd }t;|d k(sJ|dj<rJ|jj?|jA||djBtD)NrrzhNo 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)rrrr)#rrrr[rrallow_empty_graphsrrdrrrrrrr SkipFramer6rrrr^rrrrrr?rrr@rr)rr3)rrrs r_returnzInstructionTranslator._returns //1''333+++'' 0043C3CC )) '')Q.22==?KKNN--33--0=>@  $(   LL' (;(;'9qq %A% !,-222,Q/@@@@ ++  ) )$0I!0L0V0V W rc&|j|yrrrs rrz"InstructionTranslator.RETURN_VALUE Trc&|j|yrrrs rrz"InstructionTranslator.RETURN_CONSTrr)rr>r)$rrrrr&rrArrCrrzOptional[tuple[Any, ...]]rZrrrrerrrrrrfrrgrrrrrTrrrrrrr)rrTrrrr)rrrr rrPrQrWrIr_r}rrrrrrQrRs@rr>r>s##c'cc! c " c # c+c$'c%cccc cc(c %!c"6#c$*%c& 'cJ> -^rr>r,INPLACEreBINARY_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_stackr8rrrtimetime_nsr start_time_ns child_time_nsrrrrrco_coder record_timingadd_child_time) rrdget_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--J0cFeZdZUdZded<ded<e ddZe ddZe ddZ dd Z dfd Z e dd Z dd Zdd Zdfd Z dfd ZddZddZ ddZdfd Zdfd ZxZS) rz Trace and inline a called methodrsymbolic_resultrr cd}tj|jfd5|j|||}|j cdddS#1swYyxYw)Nc"jdzSrhr)r srrz;InliningInstructionTranslator.inline_call..!sF4G4G!4Kr)rrrbuild_inline_tracer inline_call_)rr funcrrtracers ` rrz)InliningInstructionTranslator.inline_calls] MM4==?,K  ),,VT4HF&&(  ) ) )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_applyrD_originz"allowlist in dynamo known functionrzAvoid calling the function `rDroz: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:rrHrtr?rq get_functionr check_verboseskippedtorch._dynamo.variables.miscrr(rDr SkipResultr get_filenameget_namer)rrRrwr 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((   rct t|tttfsJ|j d}j j }tjs"|r |jjdx}r|}|Ftj|}|jdusJtjs|r||j<d} |j||}|Jt/j0|j3D]8} t| t4rt!d d |d | dgt*j6:j8dvrL|rt|dt:j<s-t!ddj8d|dj8dgd} t>j@jBjDjGdr&dtIjJjI} tLjNdk\r@jPjRdfd } tTjWdtY| tZjWd| |j\|rt|dt^rj ja|djb} t| t>jdjfr?tijj| tmjn| jpjrd<|rt|dttrr|djv} t| t>jdjfr?tijj| tmjn| jpjrd<t|txrJt{r1t}|j~jj|}|St|j~jj|}|S#t$r}t!dd|j#d|j%d|j j&d|D cgc]} | j)ncc} wc} d| d|j#d gt*j,| Yd}~d}~wwxYw) NFz2failed to bind arguments when attempting to inlinezfunc='z' rz ; args = z ; kwargs = z4Argument mismatch when attempting to trace function rGrz:Encountered unconverted argument when attempting to inlinezfunc: z, arg: zWAn argument to an inlined function was not successfully converted to a VariableTracker.r)rkrrz2Unsupported __setitem__/__setattr__ inline attemptz code name: z, args: zAttempted to inline z: where first argument (self) is not a user-defined object.rbytecoderr,cjjj}tj }dj d|d|S)N)rzTRACE inlined call z from r)rrrrZrr)headerrrdcur_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, %sr6r)BrHrtrrrprrrzrdont_skip_tracingpreviously_inlined_functionsrKrrr bind_argsrr:rrrrrrrrrrbrrrrrr _internal log_stateis_artifact_enabledr[BytecoderLrrrrtrace_call_logrr^rrrrrrrrCrDr1rBforwardrrrrsr.&InliningGeneratorInstructionTranslatorr}r~r)r rrrrw tracing_ctxprevious_result sub_localsrr4rrrmodulerrdrrs` @@@rrz1InliningInstructionTranslator.build_inline_tracerhsX $*.     $}}mm33 ''K"-"J"J"N"Nd#) >2CCDIF>>U* **++ AG 88>  f=J%%%!2!2!45 Aa1X$TF'!5 y9-889   <<9 9 ZQ)L)LM L%dll^8D6B24<<.@z{   >> # # - - A A* M#,,t,00234F   w &11H --K R R  z2H'I J %tVV]]C JtAw(89]]00a1C1CDF&%(("6"67 KK'(()@)@A& JtAw(EF!W]]F&%(("6"67 KK'(()@)@A&d$8999  ;''44,,F& 3''44,,F }  L  1D4E4E4G3H$--/JhJhIij8<=3??,==>k&SRSWS`S`SbRccde&11   s%P R7AR2Q548R22R7c$|j}d|_d|_|j}t j }|j r|j|j } |5|jddd|j |_d|_|j"j$rt&S|j(J|j*|j*ur%|j,j/|j,|xj0|j0zc_tjd||j"j2j4j7|t8j:st=|t>r|j@rtC|rtt=|t>rd|jDrXt=|t>sJg}|j(jGs |j(g}tjHtJ||y|j(StC|rMt=|t>sJ|j(jGsJtM|jNtQS|j(S#1swYxYw#tj$r#}d|d|}tj|d}~wt$r }d|_d}~wt$rtjd|wxYw#|j |_d|_wxYw) NFTz!Observed exception DURING INLING z : zFAILED INLINING %szDONE INLINING %srr))r rrrrP nullcontextrrrrrrrr;r!r rrrrgrrAr}rrrz traced_coderrrrHris_generator_from_ctx_managerr.generator_exhaustedis_constant_nonerrrzgenerated_itemsra)rr rd strict_ctxrrRrs rrz*InliningInstructionTranslator.inline_call_s&+#(,%{{$002  " "55f6M6MNJ 2   &+/*C*CF ',1F ) ;; " ") )##/// >>V-- -  # # * *4+@+@ A((D,J,JJ( $d+ ##//66t<  4 4 tC D22T"t%KL,,!$(NOOO++<<> 001D,,]DtL+++D!!$(NOOO++<<>>>+(("2"4 +++A  $$ 5dV3qcBC IIcN  !AL   II*D 1  +/*C*CF ',1F )sH#J %I<6J <JJ K2J:: K2K$K22K55Lcj|j}|d} t| ts | j} |jj } | r| j j|nd} | %| j} | j} | j}n`t|} t| t| } tDcic]}|t||}}| rt!| | || j |<t"|I|ji|| ||||| |||j&|j(dz|j*|j,|j.|j0| ||_||_|j6|_d|_|j:j=|_|j>|_ycc}w)N __builtins__)rrrr)rr&rArCr|r}r~rrrrrrrrrrr) get_globalsrHr__dict__rrzinlined_code_cacherKrrrr"r!rr,rrrHrIrrrrrrfuncvarr rrrr8r)rr rdr|r}r~rrrArCrcachedrrrrrPs rrIz&InliningInstructionTranslator.__init__;s'') ~. *d+#,,Jmm33 =H//33D9d  !..LnnG!..L/5L  -!,/G9FIAAwtQ//ILI7G!-#!-8 ..t4 ==!+-*G"7%%==,,q0"22,,$66NN%  (  ))#%55::<))CJs<F0c.|jjSr)r r{rs rr{z'InliningInstructionTranslator.fake_modezs{{$$$rc\tj|jjSr)rrr rrs rrz)InliningInstructionTranslator.run_ctx_mgr~s ++DKK,E,E,GHHrctjsy|jjsy|jj 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 should_allow_nested_graph_breaksr rrs rrvzAInliningInstructionTranslator._can_speculate_comprehension_nesteds9 ))||<<>{{779rctjrD|jjsy|jj syt |Syr)rrrrr rrHrrPs rrz:InliningInstructionTranslator.should_compile_partial_graphsC  % %<<@@B;;;;=779 9rcdtjrt| ||St dddgy)NzGraph break in inlined functionrz2Graph breaks in an inlined call are not supported.r)rrrHrr:)rrrrPs rrz3InliningInstructionTranslator.create_call_resume_ats5  % %707PQ Q5L  rcF|j|_d|_tr)rrrr3rs rrz*InliningInstructionTranslator.RETURN_VALUEs#xxz#' rcH|j||_d|_tr)r>rrr3rs 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_rZ___unnamed_scope)rArXrKrrr_r`rrdrMrrurOrNrOrS) rrrLrMrN 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)rrArErrcrHrIrr.has_pending_mutation_of_attrr8 load_attrrbrG)rrrrrrrrPs rrIz*InliningInstructionTranslator._load_globals{{ 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)rTr) rrcrArHrXrrHrr:rrr. store_attr)rrrr_fglobals_valuerrrPs rrXz*InliningInstructionTranslator.STORE_GLOBALs ;; # #t~~ 5 G  &HHJE%!89Q KK 8  ;;D.2.O.OPT.U +O[! KK $ $ / / T5 Ir) r rrrorrrr{rrb)rrorztrace_rules.SkipResult) r rrrorrrr{rrr)r rrdrr|r{r}r{r~rrrrz7BaseUserFunctionVariable | LocalGeneratorObjectVariablerrrrrrr)rrrz#tuple[Any, VariableTracker, Source])rrrrrrrr rrrrIrr{rrvrrrrrrIrXrQrRs@rrrs*.. %% ) )' )( ) + )  ) )?&? ??BCC&C(C+ C ' CCJK,Z=*)=*=*4 =* 5 =* (B =* 3=*I=* =*~%%I     $=       (:(: ,(:TM"JJrrcxeZdZUded<d fd Zd fd ZddZddZddZdfd Z dfd Z dd Z dd Z xZ S)rrrcNt||i|g|_d|_d|_yr)rHrIrrr)rrrrPs rrIz/InliningGeneratorInstructionTranslator.__init__s- $)&)!#( -2*rctjjfd5tcdddS#1swYyxYw)NcjSrrrsrrzEInliningGeneratorInstructionTranslator.inline_call_..s 4CTCTr)rrrrHrrs`rrz3InliningGeneratorInstructionTranslator.inline_call_s8 dkk;T U *7') * * *s ?Acyrrrs rrzCInliningGeneratorInstructionTranslator.should_compile_partial_graph src.|j}|jj|t|jtkDrt j |jttjs |jr ||_ tyr)rrrrrvrInfiniteGeneratorErrorr8rgrrrrr5)rrtops r YIELD_VALUEz2InliningGeneratorInstructionTranslator.YIELD_VALUEsshhj ##C( t## $'9 9,, , ()  5 511#&D   2rc|jd}t|tsC|jt t j ||gi}|j|yyr)rrHrzrrfrr9r8)rrrress rGET_YIELD_FROM_ITERz:InliningGeneratorInstructionTranslator.GET_YIELD_FROM_ITERsNjjn#34 HHJ!$'55dSE2FC IIcN5rc0d|_t| |Src)rrHrrrrPs rrz3InliningGeneratorInstructionTranslator.RETURN_VALUE$#' w#D))rc0d|_t| |Src)rrHrr s rrz3InliningGeneratorInstructionTranslator.RETURN_CONST(rrct|jdk\sJ|j}|jd}|jst dddg |j |}t |jtr|jdkDsJ|xjdzc_|j||j|y#ttjf$rw}t |tjrtj||j|jtj |j"Yd}~yd}~wwxYw) NrrnUnreachable sub-generator coder@Should only be encountered while implementing generator support.rrr)rrrrr:rrHrrr8rrrrrrhrrrrr^rexs r YIELD_FROMz1InliningGeneratorInstructionTranslator.YIELD_FROM,s"4::!###hhjjjn##% 8^   ###D)C433S9,,q0 1  $ $ ) $ IIcN   T "#s<<= 9"c;;<--d3 HHJ II&--bhh7 8 8  9sCE'A-EEct|jdk\sJ|j}|jd}t|tt fs>t|t rrt|jtjjrD|jr$ |j|}|j|yt-dddgyt-dd t/|d t/|d gy#ttj f$rl}t"j$dkr|j|jt'j(|j|j+|Yd}~yd}~wwxYw) NrrnrdrrrrzSEND with bad typez TOS type: z(Attempted to SEND with unsupported type rG)rrrrHryrqrr collectionsabcIteratorrrr8rrrrLrrrhrrr:r`rs rSENDz+InliningGeneratorInstructionTranslator.SENDRs64::!###hhjjjn c,.JK L s5 6399koo&>&>?##%#++D1CIIcN< b  ,$WS\N3Fws|nTUV  5&s'D'DE $'''1 II.55bhh?@IIdOO $sC;;FA"E;;F)rrrrrrrrr)rrrrrIrrrr rrrrrQrRs@rrrs7**3 * **$#L*rr)rrrztypes.ModuleType)rr=)rrrGenerator[None, None, None])rDzCallable[..., object]rr)rNrUrr)r^rrrr)rzdict[str, dict[str, Any]])rrrCallable[[object], bool]r8rrr)rrr8rrr>)rrrr2rrrr)r8rr)rrzYCallable[[Callable[..., None]], Callable[[InstructionTranslatorBase, Instruction], None]])rr@rdrrzCallable[[], int]rr( r __future__rrcollections.abcrPr8rr[rBrr?rrrrrorL threadingrrfrIrCrtypingrrrrr 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!rr"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1codegenr2r3r4r5r6r7r8r9r:r;funcname_cacher<guardsr=r> output_graphr?r@rA polyfillsrBrCrDrErF replay_recordrGrHrrIrJrKrLrrMrNrOrPrQrRrSrTrUrVutilsrWrXrYrZr[r\r]r^r_variables.baser`rarbvariables.builderrcrdrevariables.builtinrfvariables.constantrgrhvariables.ctx_managerrirjrkrlvariables.dictsrmrnvariables.functionsrorprqrrrsrtruvariables.iterrvvariables.lazyrwvariables.listsrxryrzr{r|r}variables.miscr~rrrrrrvariables.nn_modulerrvariables.streamsrvariables.tensorrrvariables.torch_functionrrvariables.user_definedrrrrrrrrtorch._subclasses.fake_tensorrrr getLoggerrrrgetArtifactLoggerrrrrrrUrr9rrcontainsrrrrcacher dataclassrrrrrrrQrrr rrr r3r5rErOrbrtrrrrrrr?rrArTrr>rr_nb_opsrrrrr)rrrrs0000rrHs,0#     QQQ$ ROCC/</ "'   )/NN:   ;   GFRR.H <//Q2G==<'g!..228^L11(LI>>33HnM^^55h@PQioo4R4L4R4R4T',0AqAq''''^"("3"34BB X]] + 9 9 D!H! %&( y )) < CCCL     222 33. 44 )!) ))& $!$ $$ !!!H ~  I 9A  ..&  $ $  >>B (' #'&' ' 'T BA&A.2A=AHR!R'0R;LR RB} }"}}@JJ4 ___DO?;'O?;d~_5_D w   FA  !#v-F12JWVABZL3I  := := :=(:=! :=:=zjJ$=jJZ-JUy'lgs $W $W