+ ja0t$Rt^RIHt^RIt^RIt^RIt^RIHt^RI H t H t H t H t ^RIt^RIHuHt^RIHt^RIHt^RIHt^RIHt]P4!]4t] 'd^R IHtHt^R I H!t!.t"R ]#R &R t$^t%] !R]&4t'](])]&R,]&R,]&R,3,t*]+]&](]&R,]&R,3,3,R,t,]!/4t-R]#R&!RR].4t/RRlt0RRlt1RRlt2RRlt3RRlt4RRlt5RR lt6R!R"lt7R#R$lt8R%R&lt9R'R(lt:R)R*lt;R+R,ltR1t?R2R3lt@R4R5ltAR6R7ltBR8tCR9R:ltDR;tER<R=ltFR>R?ltGR@RAltH!RBRC4tIRDREltJ!RFRG4tK]K!4tLRH]LnRH]LnM]KPP]LnRI]/nORJ]/nMRI]KPnORK]KPnMR#)MaAhead-of-time precompilation (``make_fx`` tracer by default; Dynamo planned). python_code, cache = torch.compiler.precompile(fn, model, *example_inputs) f_c = torch.compiler.precompile.load(python_code, cache) out = f_c(model, *example_inputs) # pass the model again at runtime precompile captures your computation with ``make_fx`` -- a NON-STRICT trace of the ATen ops that run when ``fn`` executes once on the example inputs. It does not analyze your Python, so it comes with an explicit contract (the programming model): stay inside it and the artifact faithfully reproduces ``fn``; step outside it and you get an artifact that computes the wrong thing. ``precompile`` returns a self-contained, executable ``python_code`` string plus a companion integrity-tagged ``cache``. With ``backend="inductor"`` (the default) the captured graph is lowered through the AOT backend contract (``torch._functorch.aot_autograd.compile_to_python``, AOTAutograd + Inductor); ``python_code`` JIT-compiles kernels on first call and the cache primes them so a warm reload skips JIT. With ``backend="eager"`` ``python_code`` inlines the captured graph and runs on its own. Reload with ``torch.compiler.precompile.load(python_code, cache)``. The full contract, the calling convention, and the cache / code_hash design all live in Note [precompile programming model] below; every public entry point and guard references it. ) annotationsN)MappingProxyType)AnycastNewType TYPE_CHECKING)Tensor)make_fx) stateless)is_traceable_wrapper_subclass)CallableMappingFakeTensorMode list[str]__all__torch.compiler.precompile _ModuleIndexzMapping[int, Any] _NO_MARKSc]tRtRtRtRtR#)PrecompileErrori aThe error type raised by ``torch.compiler.precompile`` and its artifacts. Raised when capture, lowering, ``load``, or a runtime call violates the precompile contract -- e.g. a tensor baked as a constant (invariant 1), an unsupported / effectful op, a non-tensor output the inductor backend cannot lower, or a runtime input whose shape or memory format differs from the example (invariants 3 and 6). See Note [precompile programming model] in this module for the full contract. N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rR/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/_precompile.pyrr srrc V^8dQhRRRR/#)tobjectreturnztuple[int, ...] | Noner)formats"r __annotate__r&s  F 5 rc\V\P4'd'\V4'g\ VP 4#R#)aReturn the shape of a plain dense tensor, else ``None`` (non-tensor / subclass). Tensor subclasses (e.g. DTensor) go through AOTAutograd's flatten path, so their outer shape is not the dense shape the inductor artifact bakes; record ``None`` and skip them in the shape check. N) isinstancetorchrr tupleshaper"s&r _dense_shaper-s1!U\\""+H+K+KQWW~ rc V^8dQhRRRR/#r!r"r#r$ str | Noner)r%s"rr&r&$s  F z rc\V\P4'd'\V4'g\ VP 4#R#)asReturn the dtype of a plain dense tensor as a string, else ``None``. Recorded as a string (e.g. ``"torch.float32"``) so it serializes into the artifact metadata as a literal and compares cleanly against ``str(t.dtype)`` at runtime; mirrors the _dense_shape convention (None for non-tensor / subclass leaves). The graph is specialized to the example dtype (invariant 6). N)r(r)rr strdtyper,s&r _dense_dtyper4$s1!U\\""+H+K+K177| rc V^8dQhRRRR/#r/r)r%s"rr&r&1s  V  rc\V\P4'd'\V4'g\ VP 4#R#)a4Return the device (as a string) of a plain dense tensor, else ``None``. Recorded as a string so it serializes into the artifact metadata as a literal and compares cleanly at runtime; mirrors _dense_shape (None for non-tensor / subclass leaves). The graph is specialized to the example device (invariant 6). N)r(r)rr r2devicer,s&r _dense_devicer81s1!U\\""+H+K+K188} rc V^8dQhRRRR/#)r!gmtorch.fx.GraphModuler$zlist[tuple[str, object]]r)r%s"rr&r&=s    rc.pVPPRR7FPpTpVPPR4Fp\ W4R4pK VP VPV34KR V#)zReturn ``(target, attr)`` for every ``get_attr`` node, resolving dotted qualnames the same way for both capture guards below (missing attr -> None).get_attr)op.N)graph find_nodestargetsplitgetattrappend)r:resolvednodeattrparts& r_resolved_get_attrsrJ=sk H##z#2KK%%c*D4t,D+d+, 3 Orc V^8dQhRRRR/#)r!argstuple[object, ...]r$boolr)r%s"rr&r&Us  0 T rc\;QJd0R\P!V44F 'gK R# R#!R\P!V444#)zXTrue if any tensor reachable in ``args`` carries a mark_unbacked dim (backed or strict).c3"TFIp\V\P4;'d#\VRR4;'g\VRR4xKK R#5i)_dynamo_unbacked_indicesN_dynamo_strict_unbacked_indices)r(r)rrD.0r"s& r &_has_unbacked_marks..Xs[ *A 1ell#  A14 8 C Cq;TB *s%AAATF)anypytree tree_leaves)rLs&r_has_unbacked_marksrZUsY 3 ##D) 3333 ##D)  rc V^8dQhRRRR/#)r! user_flat list[object]r$Noner)r%s"rr&r&bs,,,$,rc VFp\V\P4'gK%\V4'd2\ VRR4'g\ VRR4'd \ R4h\ VRR4'd \ R4h\ VRR4pV'gK\ ;QJd*RVP44F 'gK R M R M!RVP444'gK\ R 4h R#) a"Reject mark options precompile cannot honor, loudly (invariant 3). precompile only honors mark_unbacked (backed unbacked dims) and mark_unbacked's strict variant. Backed dynamic marks (mark_dynamic -> _dynamo_dynamic_indices) and per-dim specialization (_specialize_on) have no analogue in the static/unbacked capture path -- silently dropping them would bake a wrong artifact, so reject rather than ignore. (mark_unbacked's hint_override is NOT rejected: it is a perf-only autotuning size hint, never a guard, so the single artifact is valid regardless; it is threaded into the capture ShapeEnv in _fakeify_with_unbacked.) A mark_unbacked dim on a tensor SUBCLASS (e.g. DTensor) is rejected: the dynamic capture cannot preserve the subclass through the refake, so it too would bake a wrong artifact. rQNrRzprecompile: an input is a tensor subclass (e.g. DTensor) with a mark_unbacked dynamic dim, which precompile cannot honor: the dynamic capture cannot preserve the subclass. Mark a dense input instead, or capture that dim static (do not mark_unbacked it)._dynamo_dynamic_indiceszprecompile: an input has a mark_dynamic (backed dynamic) dim, which precompile cannot honor; it supports only mark_unbacked dynamic dims. Use torch._dynamo.decorators.mark_unbacked, or leave the dim static._specialize_onc3$"TFqxK R#5iNr)rTvs& rrU,_reject_unsupported_marks..s C,Bq,BsTFzprecompile: an input has a mark_unbacked specialize_on list, which precompile cannot honor (it produces a single artifact, not per-value specializations). Remove specialize_on.)r(r)rr rDrrWvalues)r\r" specialize_ons& r_reject_unsupported_marksrhbs!U\\**  ) + + A14 8 8q;TBB!E  1/ 6 6!W   #3T: =SS CM,@,@,B CSSS CM,@,@,B CCC!: 7rc V^8dQhRRRR/#)r!r\r]r$list[dict[int, _MarkSpec]]r)r%s"rr&r&s%%L%5O%rc .pVEFKp\V\P4'gVP/4K7\ \ VRR4;'gR4pT\ \ VRR4;'gR4,pV'gVP/4K\ VR\ 4;'g\ p\ VR\ 4;'g\ p\ VR\ 4;'g\ pTPVUu/uF9pWtPV4.VPVR4OVPV4N5bK; up4EKN V#uupi) aRead ``torch._dynamo.decorators.mark_unbacked`` marks off the user-input tensors. Dynamic shapes are opt-in via that decorator (the caller marks dims before calling precompile), NOT via a precompile kwarg -- so the precompile signature stays simple. Returns a per-leaf list aligned to ``user_flat``; each entry maps a marked dim to ``(shape_id, min, max, hint_override)`` (None when unset), empty when the leaf has no marks. Dims sharing a ``shape_id`` get the SAME unbacked symbol (so they are equal by construction); ``min``/``max`` become runtime range asserts; ``hint_override`` is a perf-only autotuning size hint applied to the symbol in _fakeify_with_unbacked. rQNrR_dynamo_shape_ids_dynamo_unbacked_bounds_dynamo_hint_overridesr)NN)r(r)rrEsetrDrget)r\marksr"idx shape_idsboundshintsds& r_read_unbacked_marksrws*)+E !U\\** LL  '!7>DD"E s71?FLL"MM LL  A2I>KK) 5yANNY3Y?LL9  AMM!$Qvzz!\'BQEIIaLQQ  '2 L  s ?E c V^8dQhRRRR/#)r!rqrjr$list[_LeafBounds]r)r%s"rr&r&s8=Nrc.pVFLp/pVP4FwpwrVrxVfVfKWg3W4&K TPT;'gR4KN V#)aBuild the per-leaf runtime min/max bounds from the already-read mark_unbacked marks, aligned to ``user_flat`` (so ``marks`` is the output of _read_unbacked_marks). mark_unbacked promises (in its own docstring) a runtime check that the dim is >= min and <= max; those bounds are applied as capture-time torch._check constraints in _fakeify_with_unbacked, but unbacked symints cannot be guarded on, so they never become a runtime guard on their own. We record them here so the driver enforces them. Each entry is None when the leaf has no bounded marked dim, else a dict mapping a marked dim index to ``(lo, hi)`` (either may be None); mirrors USER_INPUT_DTYPES. N)itemsrE) rqrtperper_leafrv _shape_idlohi_hints & r_read_input_boundsrsa!#F=?-0YY[ )A) r~!h .9  h&&$'  Mrc V^8dQhRRRR/#)r!r"z torch.Tensorr$ztorch.memory_formatr)r%s"rr&r&s\.Arc\VP\PR7'd\P#VP\PR7'd\P#VP\PR7'd\P#\ R4h)aReturn the example leaf's memory format so a refaked marked input preserves it. A mark_unbacked dim refakes the leaf via torch.empty; defaulting to contiguous would bake a contiguous assert_size_stride and reject a channels_last / transposed input even at its own layout. Probe the recognized formats and raise on an exotic / ambiguous layout we cannot capture rather than silently forcing contiguous. ) memory_formata\precompile: a mark_unbacked input has a memory format that is neither contiguous, channels_last, nor channels_last_3d (e.g. a transposed or otherwise non-standard layout); the dynamic-shape capture cannot preserve it. Pass the input in one of those layouts (.contiguous() to make it contiguous), or capture the dim static (do not mark_unbacked it).) is_contiguousr)contiguous_format channels_lastchannels_last_3drr,s&r_detect_memory_formatrs U%<%<==&&&U%8%899"""U%;%;<<%%%  ? rc(V^8dQhRRRRRRRR/#) r!pb_flat list[Tensor]r\r]rqrjr$z#tuple[list[object], FakeTensorMode]r)r%s"rr&r&s2C-C- C-&2C-;UC-(C-rc *^RIHp^RIHpV!4pV!VRR7p/pT;_uu_4VUu.uFqP VRR7NK p p.p \ W4EFwr\ V \P4'gV PV 4K9V 'g%V PVP V RR74Ke.p \V P4EF)wrW9dV P\V44K(W,wppppVe^VV9dWVV,pVe\P!VV84Ve\P!VV8*4V PV4KVP4p\P!V^84Ve\P!VV84Ve\P!VV8*4VeVPVV4VeVVV&V PV4EK, \!V 4p\P"!V V P$V P&VR7pVP)V P*4V PV4EK RRR4.X OX OV3#uupi +'giL;i)aFakeify the flat capture inputs for an unbacked dynamic-shape capture. Params/buffers and unmarked dims become static fakes; each mark_unbacked dim becomes an UNBACKED SymInt (unguardable, so the artifact is valid for any runtime size and a graph that needs to guard on it fails at capture). Dims sharing a ``shape_id`` reuse one symbol; ``min``/``max`` add runtime asserts. Returns ``(flat_fake, fake_mode)``; the fake_mode (ShapeEnv) is threaded to the lowering via from_tracing_context. r)ShapeEnvT) shape_envallow_non_fake_inputs) static_shapesN)r3r7r)torch._subclasses.fake_tensorr%torch.fx.experimental.symbolic_shapesr from_tensorzipr(r)rrE enumerater+int_checkcreate_unbacked_symint"_set_unbacked_var_to_hint_overrideremptyr3r7requires_grad_ requires_grad)rr\rqrrr fake_modesharedr"fake_pb fake_userleafr|sizesisshape_idrrhinturfs&&& r_fakeify_with_unbackedrs,=> I$OI "F IPQA(($(?Q"$ Y.IDdELL11  &  !6!6t4!6!PQ#%%djj1DA| SV, -0V*Hb"d+F0B"8,>!LLb1>!LLb1 Q !88:ALLa(~ Q"W-~ Q"W-'!DDQM++,x(LLO;2<!6d ; KK**;;"/    !3!34  #[/ b "W !y !9 ,,aR s$JI= AJGJ=J J c V^8dQhRRRR/#r!r:r;r$r^r)r%s"rr&r&+s  #7 D rc \V4UUu.uFRwr\V\P4'gK'V\ VP 4\ VP43NKT pppV'd\RV R24hR#uuppi)aEnforce invariant 1 of Note [precompile programming model]: everything live is an input. Every legitimate tensor in a non-strict capture is a placeholder (a lifted parameter/buffer or user input) or the result of a ``call_function`` node. A ``get_attr`` pointing at a tensor therefore means some tensor was closed over (a global, captured local, or non-registered module attribute) and would be baked into the graph as a constant, which we forbid. aprecompile traced a tensor that is neither a graph input (module parameter/buffer or user input) nor an intermediate. Such tensors would be hard-coded into the graph. This fires for a tensor closed over by fn (a global or captured local) or a plain (non-registered) module attribute, and also for a tensor literal constructed inside fn (e.g. torch.tensor([...])). Offending constants (target, shape, dtype): z. Fix by passing the tensor as an explicit argument; for module state register it as a parameter/buffer, and for a literal hoist it out of fn and pass it as an argument.N) rJr(r)rr*r+r2r3rr:rBrH offendings& r_check_no_constant_tensorsr+s033LF dELL ) 5tzz"C O43  ' (1k2O  O   s $B/Bc V^8dQhRRRR/#rr)r%s"rr&r&Hs  *> 4 rc\V4UUu.uF3wr\V\PP4'gK1VNK5 pppV'd\ RV R24hR#uuppi)aReject captured control-flow HOP subgraphs (e.g. from ``torch.cond``). They appear as ``get_attr`` nodes pointing at nested ``GraphModule`` submodules. The eager backend inlines ``gm.code`` and cannot reach such submodules (they are not on the standalone ``_GraphSelf`` holder), and the standalone composition does not inline them either, so the artifact would crash at runtime. Fail at capture with a concrete reason instead, like ``_assert_supported``. zprecompile cannot lower a captured control-flow subgraph (e.g. from torch.cond / torch.while_loop); not supported yet. Offending get_attr targets: r?N)rJr(r)fx GraphModulerrs& r!_assert_no_control_flow_subgraphsrHsn033LF dEHH00 1 3  !{! %   s .A$A$c V^8dQhRRRR/#)r!modszlist[torch.nn.Module]r$zStuple[list[Tensor], list[str], list[str], list[tuple[_ModuleIndex, str, int]], int]r)r%s"rr&r&^s"4H4H 4H4Hrca a a a \V4^8dRRlo MRRlo .o /o .o RV V V V 3Rllp.p\V4F3wr4VPRR7FwrVV!\V4WVV4K K5 \S 4p.p\V4F3wr4VP RR7FwrYV!\V4WYV4K K5 S W(S V3#) aLift each module's parameters then buffers to a flat list, interning by tensor identity so a tied weight becomes a single entry (one optimizer step, accumulated gradient -- not one per name). Returns ``(pb_flat, param_names, buffer_names, alias_entries, num_params)``, where ``alias_entries`` maps each ``(module_index, name)`` to its index in ``pb_flat`` (used to reparametrize during capture). This same params-then- buffers, intern-by-identity order is reproduced at runtime against the user-supplied modules, so the dense list lines up with the compiled graph. INVARIANT: the all-modules' params then all-modules' buffers, dedup-by-id ordering here is load-bearing and is reproduced VERBATIM by ``torch._precompile_driver._extract_param_buffers`` (emitted into the inlined/eager load paths). The cached load path uses this function directly, so both must stay in sync; ``test_cached_and_inlined_paths_agree`` cross-checks them. c$V^8dQhRRRRRR/#r!mirnr2r$r)r%s"rr&+_intern_param_buffers..__annotate__us!  l s s rcRV RV 2#)mr?rrrs&&r_name$_intern_param_buffers.._nameusrd!A3< rc$V^8dQhRRRRRR/#rr)r%s"rr&rys!  l s s rcV#rcrrs&&rrrysHrc ,V^8dQhRRRRRRRRR R /#) r!rrrr2r"r names_outrr$r^r)r%s"rr&rs/,,L,S,V, ,d,rc<SP\V44pVfB\S4pVS\V4&SPV4VPS!W44SPWV34R#rc)rpidlenrE) rrr"ruidxr alias_entries id_to_uidxuniques &&&& r_intern&_intern_param_buffers.._internsa~~be$ <v;D $Jr!u  MM!    U2\ *bT]+rF)remove_duplicate)rrnamed_parametersr named_buffers)rr param_namesrrrp num_params buffer_namesbrrrrs& @@@@r_intern_param_buffersr^s* 4y1}  F!#J9;M,, K4&&&>DA L$aK 8?!VJ L4OOUO;DA L$aL 9<! ;mZ GGrc(V^8dQhRRRRRRRR/#) r!fnCallable[..., object]rLrMdecompositions dict | Noner$_Capturer)r%s"rr&r&s6www w w wrc t aaaa$a%a&a'a(a)a*a+a,^RIo'\S4o\S4UUu.uF3wr4\V\P P 4'gK1VNK5 ppp\V4o*SUu.uF1p\V\P P 4'gK/VNK3 upo)\;QJd .V*3Rl\S44FNK 5M!V*3Rl\S444p\S)4wrxp o$o+\V4o,VRS+U u.uFp \V P4NK p p VS+RU u.uFp \V P4NK p p VRS+U u.uFp \V P4NK p p VS+RU u.uFp \V P4NK pp VRS+U u.uFp \V P4NK pp VS+RU u.uFp \V P4NK pp \P!V4wpo(\!V4.VOVOp\#V4pVU u.uFp \%V 4NK pp VU u.uFp \'V 4NK pp VU u.uFp \)V 4NK pp \+V4p\-V4pVUu.uF1p\V\P.4'd VP0MRNK3 ppVF,p\V\P.4'gK%RVnK. Rp\3V4'dz\5VVV4wpp\7VV4UUau.uFPwpoVfRMC\;QJd .V3Rl\V44FNK 5M!V3Rl\V444NKR pppRo&.o%RV$VV%V&V'VV(V)V*V+V,3 Rllp^RIHpVeRMRpVeTMS'P=4p \P>!4;_uu_4T ;_uu_4\AVVVR 7!V4p!RRR4RRR4\7TT4F/wpp#\T\P.4'gK(T#TnK1 \GX!4\IT!4\KT!4\MR /R T!bR TbR TbR\S4bRTbRT bRT bRT bRT bRTbRTbRTbRS(bR\ORS&4bRS%bRTbRTbRTbRTbRTb#uuppiuupiuup iuup iuup iuup iuup iuup iuup iuup iuup iuupiuuppi Td3p"\CR \T"4PE4^, 24T"hRp"?"ii;i +'giELP;i +'giEL\;i \7TT4F/wpp#\T\P.4'gK(T#TnK1 i;i)!aTrace the computation ``fn(*args)`` to an ATen graph. See Note [precompile programming model] for the contract. ``fn`` is the whole computation, e.g. ``lambda model, x: model(x)`` or a training step ``lambda model, x, t: loss_fn(model(x), t).backward()``. Among ``args``, the ``nn.Module`` arguments have their parameters/buffers lifted to explicit graph inputs (via reparametrization, so nothing is baked -- invariant 1); the remaining arguments are the runtime inputs. Whatever ``fn`` returns becomes the graph's result outputs, and if ``fn`` ran a backward, the resulting parameter gradients (read off ``param.grad``) are harvested as additional, trailing graph outputs. They are kept separate from the result so the driver can scatter them onto the runtime model's ``.grad`` fields rather than return them (invariant 5). This is a NON-STRICT trace (invariant 3): make_fx records only the ATen ops that run for THIS example. Python-level control flow over tensor values, data- dependent branches, and shapes are specialized to ``args`` and baked. The interning/order established here for params then buffers is the calling convention the runtime model must reproduce (invariant 2). Nc3><"TFwrVS9gKVxK R#5ircr)rTramodule_pos_sets& rrU_capture..sQoda.9Pos  c3><"TFwrVS9dRMTxK R#5ircr)rTrrr|s& rrUrsK?41qCxtQ.?sc V^8dQhRRRR/#)r!flatr]r$r)r%s"rr&_capture..__annotate__s?*?*l?*|?*rc < \RVRS 4p\P!VS RS4pSP4;_uu_4p\ S4FSwrESUUUu/uFwrgqV8XgKWqV,bK p pppVP \ P!WYRR74KU .p ^p \\S44FDp V S9dV PSV ,4K$V PW+,4V ^, p KF S!V !p VRSpVUu.uFqPNK pp\;QJdRVSR4F 'gK RM RM!RVSR44'd \R4h\;QJdRVS R4F 'gK RM RM!RVS R44'd \R4hRRR4\P!X 4wpp.p.p\ X4F.wp pVfK VPV4VPV 4K0 VoVo.VOVO#uupppiuupi +'giL;i) rNT) tie_weightsc3@"TFp\VRR4RJxK R#5igradNrD)rTrs& rrU,_capture..flat_fn...sQA71fd+47Fzprecompile: a registered buffer received a gradient (it has requires_grad=True), but precompile only harvests gradients for parameters. Register it as an nn.Parameter instead.c3@"TFp\VRR4RJxK R#5irrrSs& rrUr8sOA71fd+47rzprecompile: a user input received a gradient; precompile only harvests gradients for parameters, so an input gradient would be silently dropped. Pass the tensor as a module parameter if its gradient is needed.)rrXtree_unflatten ExitStackr enter_contextr _reparametrize_modulerangerrErrWr tree_flatten)!rpbruntime_inputsstackrremirrreparamfulluirresult param_proxiesr harvested result_flat result_spec grad_flatgrad_param_indicesgrrLcaptured_grad_param_indicescaptured_out_spec contextlibrin_specrrrnum_pbs!& rflat_fn_capture..flat_fns'.$w- 0..tFG}gF  ! ! # #u"4;HV=<34SUI;1h;=V##33ADQ)"$DB3t9%&KKQ(KK 23!GB & YF{ OM)67AI7sQJKQsssQJKQQQ%JsOfgOsssOfgOOO%*PC$`$*#6#6v#> [ i(DAq}  #"))!,)(&8#))y))oW"8'$ #sOH: H.* H.7BH:H5)!H: H:+H:H:H:6 H:. H:: I )GuardOnDataDependentSymNodesymbolicreal)decomposition_table tracing_modea precompile: fn needs to guard on a dim marked with mark_unbacked (it branches on or specializes that size), which is not allowed for an unbacked dynamic dim. Do not mark that dim (capture it static), or restructure fn to avoid the size-dependent operation. Underlying: r: flat_argsmodule_positionsnum_positional_argsrr param_shapes buffer_shapes param_dtypes buffer_dtypes param_devicesbuffer_devicesr out_specpytree.TreeSpecruser_input_shapesuser_input_dtypesuser_input_devicesuser_input_boundsrr)(r r*rr(r)nnModulerorrr+r2r3r7rXrrhlistr-r4r8rwrrrrWrrrr nullcontext enable_gradr r splitlinesrr_assert_supportedrr)-rrLrrrr user_inputsrrrr"rrrrrrr\r real_flatrrr rqr! saved_gradsrbaser|r rr capture_cmr:errrrr r rrrr s-ff& ` @@@@@@@@@r_capturer/s0 ;D&/oXodaAuxx9WoX)*N >t!z!UXX__=AAt >D%QioQ%%QioQQK d#BG, z\F-4KZ,@A,@qE!''N,@LA-4Z[-AB-AU177^-AMB*1+:*>?*>QCL*>L?+2:;+?@+?aS\+?M@,3KZ,@A,@qS],@MA-4Z[-AB-Ac!((m-ANB,,[9Iwi(&'&I&I YI"+>!*A Q>3<<)Qa)<4=>Iq-*I> ! +E+51"MVVIqZ5<<88166dBIKV  a & &AFI 5zz5gy%P 9 !!2E:  ; c| K9T?KK9T?KK L;  15-/?*?*?*JR!*!6:FL'39O9O9QJ    ** (6!- #- ( ;/DAq!U\\**0r"%b)b     *  I      "  " $ " $ $ &  '):; 7  ,! ",# $.% &,' () OY > BB?@AB*>=><W z/  &\1v((*1-. 0   #-** ( ;/DAq!U\\**0s.SS5,S&SS<S#S$ S)1S.S31S8 S=%T7T3T  =T U6% U"0U 2TU"U6U -U U U  U  U"" U3 - U660V7+ V7c&]tRtRtRRRlltRtR#)riNc*lV^8dQhRRRRRRRRR R R R R R RR RR RR RR RR RRRRRRRRRRRRRRRRR R!/#)"r!r:r;rr]rz list[int]rrrrrrzlist[tuple[int, ...]]rrrrrr rrrrz#list[tuple[int | None, ...] | None]rzlist[str | None]r r!ryrzFakeTensorMode | Noner$r^r)r%s"rr&_Capture.__annotate__s,#,# ,# ,#$ ,# ! ,#  ,# ,#,,#-,# ,#!,#!,#",#!,#",# &!,#"?#,#$,%,#&-',#(-),#*)+,#, -,#rc WnW nW0nW@nWPnW`nWpnWnWnWn Wn Wn Wn Wn WnVVnVVnVVnVVnVVnR#rc)r:rrrrrrrrrrrr rrrrr r!r)selfr:rrrrrrrrrrrr rrrrr r!rs&&&&&&&&&&&&&&&&&&&&&r__init___Capture.__init__s." 0#6 &((*(**,  "4!2!2"4!2#r)rrrrrrr:rr rrrrrrrr!r rrrc)rrrrr5rrrrrrs ,#,#rra# Generated by torch.compiler.precompile -- do not edit. # # This is a SELF-CONTAINED, EXECUTABLE artifact: it runs on its own, needing no # companion cache. You provide the model(s) at runtime, exactly as the original fn # took them, e.g.: # # ns = {} # exec(open("this_file.py").read(), ns) # out = ns["forward"](model, my_input) # same args as the traced fn # # The runtime model must be STRUCTURALLY IDENTICAL to the one precompile traced # (same parameter/buffer names, order, and weight tying); only the weight VALUES # may differ (swap in a checkpoint). This artifact was produced by a non-strict # make_fx trace, so control flow and shapes are specialized to the example inputs, # and (inductor backend) each input's stride / memory format is baked too: pass # runtime inputs in the example's layout (.contiguous() to match a contiguous # example). See Note [precompile programming model] in torch/_precompile.py. # # It contains, in order: # 1. The composed graph module from aot_autograd.compile_to_python: the inlined # Inductor kernels (JIT-compiled from the embedded source on first use -- no # external cache required) plus AOTAutograd's own codegen'd prelude/epilogue # (tensor-subclass wrap/unwrap, input-mutation reflection, output aliasing), # exposing ``call(flat_inputs) -> outputs``. # 2. Calling-convention metadata. # 3. A small driver that extracts each runtime module's params/buffers (in the # same order as capture), passes them with the runtime inputs to ``call``, and # scatters any harvested gradients onto the model's .grad fields. No model # weights are embedded (you bring the model). # # The companion ``cache`` returned by precompile is purely an ACCELERATION used by # torch.compiler.precompile.load: it primes the inductor kernel caches so exec'ing this # file loads its kernels from the precompiled binaries (no JIT). This file does not read # it; running this file alone just JITs. c V^8dQhRRRR/#)r!compiledPrecompiledModuler$rr)r%s"rr&r&sLL&7LILrcZVPeVPf \R4h\P!VP4p\P!TP4pRRRRRRRTP: 2RTP: 2R TP 2R TP: 2R TP: 2R TP: 2R TP: 2RTP: 2RTP: 2RTP : 2RTP": 2RTP$: 2RT: 2RT: 2RTP&: 2RTP(: 2RTP*: 2RTP,: 2R.pT# \ \ 3dp\R4ThRp?ii;i \ \ 3dRpEL?i;i)Nz1internal: cannot build metadata before _compile()aprecompile cannot serialize the output structure of fn (its pytree TreeSpec is not JSON-serializable). This fires when fn returns an unregistered collections.namedtuple, or a registered pytree node with a non-JSON-dumpable context. Register the namedtuple via torch.utils._pytree._register_namedtuple(...) (or supply a JSON-dumpable to_dumpable_context), or return a plain tuple/list/dict of tensors.z # 2. Calling-convention metadatazimport torch as _torchz%import torch.utils._pytree as _pytreez BACKEND = zMODULE_POSITIONS = zNUM_POSITIONAL_ARGS = zPARAM_NAMES = zBUFFER_NAMES = zPARAM_SHAPES = zBUFFER_SHAPES = zPARAM_DTYPES = zBUFFER_DTYPES = zPARAM_DEVICES = zBUFFER_DEVICES = zGRAD_PARAM_INDICES = z IN_SPEC = z OUT_SPEC = zUSER_INPUT_SHAPES = zUSER_INPUT_DTYPES = zUSER_INPUT_DEVICES = zUSER_INPUT_BOUNDS = H# ======================================================================) _out_spec_in_specrrXtreespec_dumpsNotImplementedError TypeError_backend_module_positions_num_positional_args _param_names _buffer_names _param_shapes_buffer_shapes _param_dtypes_buffer_dtypes_param_devices_buffer_devices_grad_param_indices_user_input_shapes_user_input_dtypes_user_input_devices_user_input_bounds)r8 out_spec_strr. in_spec_strpartss& r_build_metadata_sectionrUs!X%6%6%>QRR ,,X-?-?@ "("7"78I8I"J  * /  X&&)* h88;< !!>!> ?@ ..12 (0034 (0034 82256 (0034 82256 82256 H4478  < <?@ [O$ l%& x::=> x::=>  < <?@ x::=> [. E^ LE  + R  "  + s) E. F.F? F  FF*)F*c V^8dQhRRRR/#)r! python_coder2r$zdict[str, object]r)r%s"rr&r&4s@@#@2C@rc^RIp0Rmp/pVPV4pTPFp\ YaP 4'd\TP4^8wdK:TP^,p\ YqP4'gKjTPT9d*TPTP4Y7P&K\PRTP4K Y#P4, pT'd\R\!T4 R24hT# \dp\R4ThRp?ii;i)aRead the calling-convention constants back out of ``python_code`` WITHOUT executing it (exec'ing the inlined Inductor output would JIT the kernels, the very work the cache exists to skip). python_code is the single source of truth: ``_build_metadata_section`` emits the constants below as top-level literal assignments, so an AST walk + literal_eval recovers them safely. The cache then only needs to carry the compiled artifact. Nz\python_code is not valid Python; it does not look like a torch.compiler.precompile artifact.zlprecompile: ignoring unrecognized top-level assignment %r while parsing artifact calling-convention metadataz3python_code is missing calling-convention metadata z=; it does not look like a torch.compiler.precompile artifact.>BACKENDIN_SPECOUT_SPEC PARAM_NAMES BUFFER_NAMES PARAM_DTYPES PARAM_SHAPES BUFFER_DTYPES BUFFER_SHAPES PARAM_DEVICESBUFFER_DEVICESMODULE_POSITIONSUSER_INPUT_BOUNDSUSER_INPUT_DTYPESUSER_INPUT_SHAPESGRAD_PARAM_INDICESUSER_INPUT_DEVICESNUM_POSITIONAL_ARGS)astparse SyntaxErrorrbodyr(AssignrtargetsNamer literal_evalvaluelogdebugkeyssorted) rWrkwantedfoundtreer.rGrBmissings & r_parse_artifact_metadatar|4s#F( "Eyy%  $ ++s4<# 1. Compiled graph (AOTAutograd + Inductor): exposes ``call``zF# 3. Driver: module params/buffers + grad scatter + calling convention_inductor_forward r<)_GENERATED_HEADERrEextendrU_emit_driver_sourcejoin)r8r~rTs&& r_build_python_sourcerws #E LL! LLQR LL! LL LL LL(23 LL! LLP LL! LL$%89: 99U ra# Generated by torch.compiler.precompile (backend="eager") -- do not edit. # # Self-contained, executable artifact: the captured ATen graph is inlined below (both # the human-readable rendering and the executable code) and runs on its own. Provide # the model(s) at runtime, exactly as the original fn took them: # # ns = {} # exec(open("this_file.py").read(), ns) # out = ns["forward"](model, my_input) # same args as the traced fn # # The runtime model must be structurally identical to the traced one (only weight # VALUES may differ), and control flow / shapes are specialized to the example inputs. # See Note [precompile programming model] in torch/_precompile.py for the full contract. c V^8dQhRRRR/#)r!r8r9r$r2r)r%s"rr&r&s**):*s*rcVPpVe VPMRpVe VPMRpVe VeVf \R4hTPP RR^4p\ P!V4p\ P!V4p\R.pVPR4VPR4VPR4^RI H pVP4Fp VPV P4K VPV4VPR4VPR4VPRV: R 24VPR V: R 24VPR4VPR4VPR 4VPR 4VPR 4VPR4VP\V44VPR4VPR4VPR4VP\!R44RP#V4#)Nz/internal: eager graph missing before _compile() def forward(zdef _graph_forward(r;zC# 1. Captured ATen graph (eager backend) -- executable and readable)_custom_builtinszclass _GraphSelf:z% _in_spec = pytree.treespec_loads()z& _out_spec = pytree.treespec_loads(zdef call(args):z2 out = _graph_forward(_GraphSelf(), list(args))zA return list(out) if isinstance(out, (list, tuple)) else [out]z3# 3. Driver: run the inlined captured graph eagerly_eager_forwardrr<)_gmr>r=rcodereplacerXr?_EAGER_GENERATED_HEADERrEtorch.fx.graphrrf import_strrrUrr) r8r:r r graph_srcrSrRrTr_cbs & r_build_eager_python_sourcers B  ^bkkG!~r||4H zW_(8OPP0EqII''0K((2L $b )E LL! LLVW LL! 0&&( S^^$) LL LL LL$% LL8qIJ LL9,9IKL LL LL LL"# LLEF LLTU LL LL(23 LL! LLFG LL! LL$%567 99U rzif __name__ == "__main__": print("forward() is ready; call it with the model(s) and inputs the traced") print("fn took, e.g. forward(model, x).") c V^8dQhRRRR/#)r!forward_fn_namer2r$r)r%s"rr&r&s1111rc|^RIp^RIHp\W 4pVP VP 4VP VP 4VP VP4VP V4PRV R2R^4.pRPRV44pRV,R ,\,#) a"Emit the runtime driver as text for inlining into python_code. The driver lives as real, type-checked code in torch._precompile_driver; here we read it back with inspect.getsource (LAZILY -- only on this emit path; load() never runs it, so a stripped-source environment only affects capture, not reload) and rename the selected forward variant to the public ``forward``. Emitting the TEXT (rather than importing the module from the artifact) keeps python_code self-contained and version-frozen (Note [precompile programming model], invariant 7).N)_precompile_driverzdef (rz c3@"TFqP4xK R#5irc)rstrip)rTblocks& rrU&_emit_driver_source..s:6%||~~6rrz ) inspectr)rrD getsource_extract_param_buffers_fail_check_structurerr _DRIVER_MAIN)rrdriver forward_fnblocksrns& rrrs21J&778&,,'&112*%--?#1 %~q F ;;:6: :D $; !L 00rc V^8dQhRRRR/#rr)r%s"rr&r&sBB.B4Brc6^RIHpVPPFxpVPR8XgK\ VP \PP4'gKLV!VP 4fKb\RVP 24h R#)aEnforce invariant 4 of Note [precompile programming model]: reject boundary effects the AOT backend's standalone composition does not handle. Detected directly from the captured graph -- no AOTAutograd coupling. Input mutation (incl. module buffers, e.g. BatchNorm running stats), tensor- subclass wrap/unwrap, output aliasing, and functionalized RNG are SUPPORTED: AOTAutograd's codegen'd prelude/epilogue is composed into the artifact (see torch._functorch.aot_autograd.compile_to_python), so they are not rejected here. Effectful ops are not supported yet (an implementation gap, not a fundamental limit), so raise here with a concrete reason rather than let the failure surface deep in the cache layer. See _unsupported for the mechanical cause. ) _get_effect call_functionNz effectful op ) torch._higher_order_ops.effectsrr@nodesr>r(rBr)_ops OpOverload _unsupported)r:rrGs& rr(r(sm< 77o %* KK..+ + 4;;'3"]4;;-#@AArc V^8dQhRRRR/#)r!reasonr2r$rr)r%s"rr&r&src \RV R24#)z,precompile cannot compile this computation: z. The graph contains an effectful op, which is not supported yet: its with_effects HOP is non-cacheable, so the compiled artifact cannot be saved and lowered to standalone source.)r)rs&rrrs  6vh?  rc]tRtRtRtRRRRRR/R R llt]R R l4tR RltRRlt RRlt RRRllt Rt R#)r9izBInternal holder for a precompiled computation / a loaded runnable.backendinductortracerr rNc ,V^8dQhRRRRRRRRRR /#) r!rrrr2rrrr$r^r)r%s"rr&PrecompiledModule.__annotate__sC7B7B !7B 7B  7B $ 7B 7Brc jWnW nW0nW@nRVn.Vn^Vn.Vn.Vn.Vn .Vn .Vn .Vn .Vn .VnRVnRVnRVnRVnRVn.Vn.Vn.Vn.Vn.VnRVnR#)Nr;)_fnrB_tracer_decompositions _artifactrCrDrErFrGrHrIrJrKrLr>r=r _graph_python_artifact_bytesrMrNrOrPrQ_loaded_forward)r4rrrrs&&$$$rr5PrecompiledModule.__init__s  -!%,.)*!(*(*4657(*)+)+*,04 1504#%-1 /1 HJ4657 .0=Arc$V^8dQhRRRRRR/#)r!forwardrrr2r$r9r)r%s"rr&rMs(&   rc &V!RVR7pWnV#)aBuild a runnable from load()'s reconstructed forward. load() does not re-run capture/_compile, so reuse ``__init__`` for all the defaults (the single definition of this object's state) and override only the reconstructed forward. All the calling-convention metadata lives in the inlined driver (``forward``) itself, so the __init__ fields (``_fn``, ``_gm``, ``_module_positions``, ``_out_spec``, ...) stay at their defaults; inspect the artifact via python_code. Nr)r)clsrrobjs&&$ r _from_loadedPrecompiledModule._from_loadedLs $(% rc V^8dQhRRRR/#)r!rLrMr$r^r)r%s"rr&r`sdd/dDdrc VPR8wd\RVP: R24hVPR8Xd\V4'd \R4h\ VP WP 4pVPVnVPVn VPVn VPVnVPVnVP"VnVP&VnVP*VnVP.VnVP2VnVP6VnVP:VnVP>Vn VPBVn"VPFVn$VPJVn&VPNVn(VPRVn*VPR8XdR#^RI+H,uH-p^RI.H/p^RI0H1p^RI2H3pR R /pVPhe\kVR 4'dR VR &VPmVPRVPnVR 7wVn8Vn9R# Tdp\uR 4ThRp?iTd#pR\wT49d \uR4ThhRp?ii;i)r zprecompile tracer=z< is not implemented yet; use tracer='make_fx' (the default).eagerzxprecompile: mark_unbacked (dynamic shapes) is only supported with backend='inductor'; eager + unbacked is not supported.N) aot_autograd) InductorError)NoRunnableInductorModuleError size_assertsTscalar_asserts)optionszthe inductor backend cannot lower a graph with no compute -- the traced fn returns its inputs or Python constants unchanged, producing no Inductor kernel. Return a computed tensor, or use backend='eager'.zUnexpected output typeszthe inductor backend cannot lower a graph whose output mixes a non-tensor Python value (e.g. float / complex / str) with computed tensors (int / bool / None outputs are fine). Return only tensors, or use backend='eager'.)rr=rrMr:rtorch._inductor.config _inductorconfigtorch._functorchrtorch._inductor.excr"torch._inductor.standalone_compilerrhasattrcompile_to_pythonrrrrr2) r4rLcapture _ind_configrrrrr.s && r_compilePrecompiledModule._compile`sV <<9 $%$T\\$4522  ==G #(;D(A(A%I 488T+?+?@!(!9!9$+$?$?!#//$11$11%33$11%33%33&55")";";")";";#*#=#= ")";";  ))#*#=#= :: ==G #  5415T($24"8    (W[BR-S-S(,G$ % 7C7U7U G--w8V8 4D  4-  "U     )CF2%.    s*5H::I9 I  I9I9I44I9c V^8dQhRRRR/#)r!rLr#r$r)r%s"rr&rs++f++rc TVPf \R4hVP!V!#)Nz_this object is not runnable; build one with torch.compiler.precompile.load(python_code, cache).)rr)r4rLs&*r__call__PrecompiledModule.__call__s6    '!F ##T**rcV^8dQhRR/#r!r$r2r)r%s"rr&rs>>>rc VPe \R4hVPR8Xd%VPf \R4h\ V4#VP 'g \R4h\ WP 4#)aiReturn the self-contained, executable Python artifact as a string. It runs on its own, needing no cache (Note [precompile programming model], "self-contained"). For the inductor backend it embeds the composed graph module from aot_autograd.compile_to_python (kernels JIT-compile on first call; AOTAutograd's prelude/epilogue inlined), the calling-convention metadata, and a ``forward()`` that takes the same args the traced fn took (the model(s) plus runtime inputs). For the eager backend it embeds the captured ATen graph (both readable and executable) plus a driver that runs it eagerly. No weights are embedded. zthis object was produced by torch.compiler.precompile.load(); the python_code you passed in is the source artifact (load() does not re-capture, so there is no python_code to re-emit from this object).rz-internal: not compiled; call _compile() first)rrrBrrrrr4s&rto_python_code PrecompiledModule.to_python_codes{    +!W  ==G #xx%&UVV-d3 3!!!!"QR R#D*<*<==rc V^8dQhRRRR/#)r!rWr0r$bytesr)r%s"rr&rs$$*$$rc  VPe \R4hVfVP4p\P!VP 44P 4p\P!4p\P!R\R\RVPRVRVP/V4VP4#)aReturn the binary cache as bytes -- an ACCELERATION, not required to run. ``python_code`` is the single source of truth for the calling convention, so the cache holds only the compiled artifact plus the integrity tag and code_hash. For the inductor backend that artifact is the ``save_cache_artifacts`` bundle (load primes the kernel caches with it, so a warm reload skips JIT); for the eager backend it is None. See Note [precompile programming model], invariant 7. ``python_code`` defaults to what ``to_python_code()`` would emit; ``__call__`` threads in the exact string it already built so code_hash matches the bytes returned to the user and the metadata is not rebuilt. zthis object was produced by torch.compiler.precompile.load(); the cache you passed in is the source artifact (load() does not re-capture, so there is no cache to re-emit from this object).r%versionr code_hashartifact)rrrhashlibsha256encode hexdigestioBytesIOr)save _CACHE_FORMAT_CACHE_VERSIONrBrgetvalue)r4rWrbufs&& rto_cache_bytes PrecompiledModule.to_cache_bytess    +!B   --/KNN;#5#5#78BBD jjl ->4==YD00    ||~r)rrrBrLrJrFrHrrrrMrr>rrCrDr=rKrIrErGrrQrPrOrNrc) rrrrrr5 classmethodrrrrrrrrrr9r9s\L7B" 7B  7B '+ 7Br&dL+>4$$rr9c V^8dQhRRRR/#)r!rWr2r$rr)r%s"rr&r&s??s?/D?rc\PR4RR/p\\VRR4V4\ RVR,4#)a,Fallback: execute the self-contained python string (JITs kernels). ``python_code`` needs no cache -- the kernels (inductor) or graph (eager) are inlined, so we just exec it and hand back its ``forward``. The returned ``forward`` takes the same args the traced fn took (model(s) plus runtime inputs).ztorch.compiler.precompile.load is about to EXEC python_code, which is untrusted executable input (it runs inlined kernels / graph code). Only exec python_code you produced or otherwise trust (Note [precompile programming model], invariant 7).r_precompiled_artifactz execrr)rtwarningrcompiler)rW module_nss& r_make_inlined_forwardrsHKK  %/0G#HInf 5yA '9)= >>rcb]tRtRtRtRt]tRRltRRltRR R R R R /RRlltRRlt Rt R #)_PrecompileApii&aCallable namespace implementing ``torch.compiler.precompile`` and ``.load``. A single instance is exposed as ``torch.compiler.precompile``; calling it precompiles a computation and ``torch.compiler.precompile.load`` reloads the resulting artifacts. It is a class (rather than a function with attached attributes) so the call, the loader, and the error type are explicit members. The contract for both ``__call__`` and ``load`` is Note [precompile programming model] in this module. torch.compilercV^8dQhRR/#rr)r%s"rr&_PrecompileApi.__annotate__9sCrc R#) precompilerrs&r __reduce___PrecompileApi.__reduce__9s rcV^8dQhRR/#rr)r%s"rr&r @s++#+rc R#)rrrs&r__repr___PrecompileApi.__repr__@s*rrrrr rNc 0V^8dQhRRRRRRRRRR R R /#) r!rrexample_inputsr#rr2rrrr$ztuple[str, bytes]r)r%s"rr&r CsVIAIA !IA IA IA  IA $ IA IArc \PPR4VR9d\RV: R24hVR9d\RV: R24h\ WW4R7pVP V4VP 4pWvPV43#)aAhead-of-time precompile ``fn`` against ``example_inputs``. .. note:: ``torch.compiler.precompile`` is NOT ``torch._dynamo.config.caching_precompile`` (a ``torch.compile`` guard-serialization caching mode); it captures ``fn`` ahead of time and lowers it to a self-contained Python source artifact. With the default ``make_fx`` tracer this is a non-strict trace with an explicit contract; read Note [precompile programming model] before using it. The artifact faithfully reproduces ``fn`` only for callers that uphold that contract. THREADING: the inductor lowering step drives process-global compiler state and is serialized by an internal lock, so concurrent ``backend="inductor"`` calls lower one at a time. The make_fx capture phase and the ``backend="eager"`` path are NOT serialized. ``backend`` selects how the captured graph is realized: - ``"inductor"`` (default): lower the graph through ``torch._functorch.aot_autograd.compile_to_python`` (the full AOTAutograd + Inductor pipeline, composed into one self-contained module). ``python_code`` is the inlined Inductor output with AOTAutograd's prelude/epilogue; the cache holds the save_cache_artifacts bundle that primes the inductor cache on load. - ``"eager"``: do NOT lower -- keep the captured ATen graph and run it as-is (analogous to ``torch.compile(backend="eager")``). ``python_code`` inlines the readable captured graph (both the inspectable rendering and the executable artifact); the eager cache carries no compiled artifact (artifact=None) but is still a full integrity-tagged envelope -- with no kernels there is nothing to accelerate, so ``load`` runs the inlined graph. Useful for inspecting/debugging exactly what was traced without an Inductor dependency. ``tracer`` selects the capture front-end: - ``"make_fx"`` (default): a NON-STRICT make_fx trace -- it records the ATen ops that actually run when ``fn`` executes once on the example inputs and does not analyze your Python, so control flow and shapes are specialized to the example (the source of the programming-model contract). The only tracer implemented today. - ``"dynamo"``: planned (a Dynamo-based front-end that analyzes the Python); raises ``NotImplementedError`` for now. ``decompositions`` is an optional decomposition table (a dict mapping each ``OpOverload`` to a decomposition function) forwarded to ``make_fx`` as its ``decomposition_table`` during capture, so you can control how ATen ops are broken down in the captured graph. Defaults to ``None`` (make_fx's default). Dynamic shapes are opt-in via ``torch._dynamo.decorators.mark_unbacked`` (inductor backend only), NOT a precompile kwarg: mark dims on the inputs before calling, e.g. ``mark_unbacked(x, 0); precompile(fn, model, x)`` frees ``x``'s batch dim. Marked dims are captured as UNBACKED symints, which cannot be guarded on, so one artifact serves any runtime size of them (invariant 3); a graph that needs to guard on / specialize a marked dim fails at capture with a ``PrecompileError``. Dims sharing a ``shape_id`` reuse one symbol (equal by construction); ``min``/``max`` become runtime asserts. Other dims stay static. Dims that MUST be equal at runtime (e.g. two inputs combined by a broadcast that requires equal sizes, ``model(a) + model(b)``) MUST be given a SHARED ``shape_id`` so a mismatch is rejected; marking two such dims INDEPENDENTLY currently bakes a SILENT equal-size assumption and a runtime mismatch does NOT raise the loud failure eager gives (invariant 3). This is a harvesting gap, not an inherent limit of the standalone artifact: the capture ShapeEnv DOES record the equality (as a deferred runtime assert, e.g. ``Eq(u0, u1)``), but precompile does not yet harvest/enforce those relational asserts in the driver -- only the decorator's declared min/max feed the runtime bound checks. A shared ``shape_id`` is the way to get the check today. Returns ``(python_code, cache)`` -- a self-contained, executable Python source string (the single source of truth for the calling convention) and a binary cache holding ONLY the backend artifact (NO metadata, NO weights). Reload a runnable with ``torch.compiler.precompile.load(python_code, cache)``. ``fn`` is the whole computation, e.g.:: python_code, cache = torch.compiler.precompile( lambda model, x: model(x), model, x ) def train_step(model, x, t): loss_fn(model(x), t).backward() # or return autograd.grad(...) python_code, cache = torch.compiler.precompile(train_step, model, x, t) Among ``example_inputs``, the ``nn.Module`` arguments have their params/buffers lifted to graph inputs (no weights are baked into the artifact -- invariant 1); the rest are the runtime inputs. The reloaded callable is invoked with the SAME argument structure -- pass the model(s) again at runtime, e.g. ``f_c(model, x)``, and that runtime model must match the example model's parameter/buffer structure (invariant 2). Arguments are matched POSITIONALLY: pass the model(s) and inputs positionally both here and at load time; keyword- argument calling conventions are not supported (a fn that relies on them would surface as a raw arity error). If ``fn`` ran a backward, the resulting parameter gradients are scattered (accumulated) onto that runtime model's ``parameters()`` ``.grad`` fields, exactly like eager ``.backward()``, so a ``zero_grad()`` / ``optimizer.step()`` loop works unchanged; the artifact returns ``fn``'s own result (``None`` for a bare ``.backward()`` step), not the grads (invariant 5). Input mutation (incl. module buffers, e.g. BatchNorm running stats in training mode), tensor subclasses (e.g. DTensor), and outputs aliasing inputs are supported -- AOTAutograd's prelude/epilogue is composed into the artifact (invariant 4), as is functionalized RNG. Caller responsibilities NOT checked here (see the Note): the runtime model must be structurally identical to the example, and control flow / shapes are specialized to ``example_inputs`` (invariants 2 and 3). Violations that ARE checked raise ``PrecompileError``: a tensor baked as a constant (invariant 1), effectful ops (invariant 4), and -- for the inductor backend -- a runtime input whose stride / memory format differs from the example's (invariant 6). rz6precompile backend must be 'inductor' or 'eager', got r?z5precompile tracer must be 'make_fx' or 'dynamo', got )rrr)rr)r dynamo)r)_C_log_api_usage_once ValueErrorr9rrr)r4rrrrrr8rWs&&$$$* rr_PrecompileApi.__call__Csp $$%@A / /H STU  . .GzQRS %   .)--/ 33K@@@rc$V^8dQhRRRRRR/#)r!rWr2cacherr$rr)r%s"rr&r s,rHrHrHErH6KrHrc ^RIp\V4p\\VR,4pRpVP!\ P !V4RR7pVPR4\8wgVPR4\8wdB\PRVPR4VPR4\\4RpVeVPR4V8wd$\R VPR4: R V: R 24h\P!VP44P!4pVPR 4V8wd$\R VPR 4: RV: R24hVPR4pTeTP(P+T4\-T4p \.P1YR7# \dh\"d5p \PR\%T 4P&T 4Rp ? LRp ? ii;i \"d5p \PR\%T 4P&T 4Rp ? LRp ? ii;i)aReconstruct a runnable from ``(python_code, cache)`` from precompile. The driver runs from ``python_code`` -- the single source of truth for the whole calling convention. ``load`` reads the cache's ``BACKEND`` (to check the pairing) and, for the inductor backend, primes the inductor kernel caches from its ``save_cache_artifacts`` bundle (via ``torch.compiler.load_cache_artifacts``) so a warm reload loads precompiled kernels instead of JIT-compiling; then it exec's ``python_code``. With no usable cache it degrades to JIT'ing from ``python_code``. Call the result with the SAME argument structure ``fn`` took -- the model(s) in their original positions plus the runtime inputs. Per invariant 2 of Note [precompile programming model], the runtime model must match the example model's parameter/buffer structure; precompile re-derives the param/buffer list from it (same interning/order as capture). Raises ``PrecompileError`` if ``python_code`` is malformed or is not a ``torch.compiler.precompile`` artifact (it fails to parse, or is missing the calling-convention metadata), if the cache's ``backend`` tag does not match ``python_code``, or if the cache's ``code_hash`` does not match ``sha256(python_code)`` -- i.e. the cache and python_code came from different ``precompile()`` calls. A cache whose ``format``/``version`` does not match (a foreign or different-build envelope) is NOT fatal: the cache is acceleration only, so ``load`` degrades to JIT'ing from ``python_code`` rather than crashing. NrYT) weights_onlyr%rztorch.compiler.precompile.load got a cache with format=%r version=%r, expected %r / %r; it is likely from a different torch build. Falling back to JIT from python_code.rzcache backend z( does not match the python_code backend zC; the cache and python_code came from different precompile() calls.rz0cache does not match python_code (its code_hash z != sha256(python_code) z); the cache and python_code came from different precompile() calls. Pair each cache with the python_code from the same precompile() call.rztorch.compiler.precompile.load could not read the cache envelope (%s: %s); the cache is likely corrupt or from a different torch build. Falling back to JIT from python_code.ztorch.compiler.precompile.load could not prime the cache from the artifact bundle (%s: %s); it is likely stale or from a different torch build. Falling back to JIT from python_code.r) torch._dynamor|rr2loadrrrprrrtrrrrrr Exceptiontypercompilerload_cache_artifactsrr9r) r4rWrr)metarrblobexpected_code_hashr.rs &&& rr _PrecompileApi.loads+8 ( 4sDO,+ ::bjj/dCDxx!]2dhhy6I7 CHHX&HHY'!"88I&'1)())<(?@//6k:BB&-^^K4F4F4H%I%S%S%U"88K(,>>)J88K033K-01GG 88J/   33H=( 4 --g-GGG    KK+Q      $  IG$$  s6EGHH H *HH  I *II r) rrrrrrr rrr rrrrrr&sY "J&O+IA" IA  IA '+ IAVrHrHrrr rzprecompile.PrecompileErrorzprecompile.loadrc)Q__conditional_annotations__r __future__rrrloggingtypesrtypingrrrrr)torch.utils._pytreeutils_pytreerXr"torch.fx.experimental.proxy_tensorr torch.nn.utilsr torch.utils._python_dispatchr getLoggerrrtcollections.abcr r rrr__annotations__rrrrr*r# _MarkSpecdict _LeafBoundsr RuntimeErrorrr-r4r8rJrZrhrwrrrrrrr/rrrUr|rrrrrr(rr9rrr rrrr )r)s@rr;sX# "44 $$6$F!1< ,  ~s+ &#*cDj#*< = 3cDj#*4556=  03 3l    0 ,^%P*.C-L : ,4Hnwt-#-#`#LL^@F."*Z 14B4~~B?*ZHZHz  # & #,,44  .;!1#4 r