3jTSSKrSSKJr SSKJr SSKrSSKJr "SS\5rS/r g)N)Literal)Self)_acceleratorGraphc ^^\rSrSrSrSSSS.S\S\\\4S-S\S S \ 4U4S jjjjr SSSS.S\S\\\4S-S\S S S4U4S jjjjr SU4S jjr SU4Sjjr SU4SjjrSU4SjjrSU4SjjrS \\\44U4SjjrSU4SjjrS\S S4U4SjjrSSjrS\S S4SjrSrU=r$)Graph a Wrapper around an :ref:`accelerator` graph that supports capture and replay. A graph captures a sequence of operations and their dependencies, allowing them to be replayed efficiently with reduced overhead. This class can be used as a context manager to automatically capture operations on the current stream. Arguments: keep_graph (bool, optional): If ``False``, the underlying graph is destroyed and the executable graph is instantiated on the GPU at the end of ``capture_end``. If ``True``, the underlying graph is preserved after ``capture_end``. In this case, the executable graph is not instantiated automatically; it must be explicitly created by calling ``instantiate``, or it will be instantiated on the first call to ``replay``. Defaults to ``False``. pool (tuple[int, int], optional): Memory pool identifier for this graph. Multiple graphs can share the same pool by passing the same identifier, which can reduce memory overhead. Defaults to ``None``. capture_error_mode (Literal["default", "global", "thread_local", "relaxed"], optional): Specifies the behavior of graph capture. The exact semantics are backend-specific. ``"default"``: backend-defined default capture behavior. ``"global"``: potentially unsafe API calls are prohibited. Errors may occur if capture in the current thread affects other threads. ``"thread_local"``: potentially unsafe API calls are prohibited. Errors occur only if capture in the current thread affects itself. ``"relaxed"``: the current thread is allowed to make potentially unsafe API calls, except for calls that inherently conflict with stream capture. Default: ``"default"``. Example:: >>> # xdoctest: +SKIP >>> x = torch.zeros([2000], device=0) >>> stream = torch.Stream() >>> graph = torch.accelerator.Graph() >>> with stream, graph: ... x += 1 >>> graph.replay() Ndefaultpoolcapture_error_mode keep_graphr r )r global thread_localrelaxedreturnc">[TU]X5$N)super__new__)clsr r r __class__s R/home/wildlama/miniconda3/lib/python3.13/site-packages/torch/accelerator/graphs.pyr Graph.__new__3sws//c<>[TU]U5 X lX0lgr)r__init__ graph_poolr )selfr r r rs rrGraph.__init__>s $"4rcJ>[TU]URURS9 g)z Begin graph capture on the current stream. All operations on the current stream after this call will be recorded into the graph until ``capture_end`` is called, using the memory pool and capture error mode provided at construction time. r N)r capture_beginrr rrs rr!Graph.capture_beginLs& T5L5L  rc">[TU]5 g)z| End graph capture on the current stream of the current device. After this call, the graph can be replayed via ``replay``. N)r capture_endr"s rr%Graph.capture_endW rc">[TU]5 g)z Instantiate the underlying graph. Will be called by ``capture_end`` if ``keep_graph=False``, or by ``replay`` if ``keep_graph=True`` and ``instantiate`` has not already been explicitly called. N)r instantiater"s rr)Graph.instantiate_r'rc">[TU]5 g)z'Replay the work captured by this graph.N)rreplayr"s rr, Graph.replaygs  rc">[TU]5 g)z Delete the graph currently held by this instance. After this call, the graph can be recaptured. Set :attr:`graph_pool` or :attr:`capture_error_mode` beforehand to use different settings on the next capture. N)rresetr"s rr/ Graph.resetks  rc >[TU]5$)a Return an opaque token representing the id of this graph's memory pool. This id can optionally be passed to another graph's ``capture_begin``, which hints the other graph may share the same memory pool. Example:: >>> # xdoctest: +SKIP >>> g1 = torch.accelerator.Graph() >>> g1.capture_begin() >>> # ... operations ... >>> g1.capture_end() >>> # Share g1's memory pool with a new graph >>> pool_id = g1.pool() >>> g2 = torch.accelerator.Graph(pool=pool_id) )rr r"s rr Graph.poolts$w|~rc >[TU]5$)z)Enable debugging mode for ``debug_dump``.)renable_debug_moder"s rr4Graph.enable_debug_modesw(**rpathc">[TU]U5$)a Dump the captured graph to a file for debugging purposes if the debugging is enabled via ``enable_debug_mode``. Arguments: path (str): Path to dump the graph to. Example:: >>> # xdoctest: +SKIP >>> s = torch.Stream() >>> g = torch.accelerator.Graph() >>> g.enable_debug_mode() >>> with s, g: >>> # ... operations ... >>> # Dump captured graph to a file "graph_dump.dot" >>> g.debug_dump("graph_dump.dot") )r debug_dump)rr6rs rr8Graph.debug_dumps(w!$''rcT[RR5 [RRR (a[ R"5 [RR5 [RR5 UR5 gr) torch accelerator synchronizecompilerconfigforce_cudagraph_gcgccollect empty_cacheempty_host_cacher!)rs r __enter__Graph.__enter__sb %%' >> 3 3 JJL %%' **, rexc_infoc$UR5 gr)r%)rrGs r__exit__Graph.__exit__s r)r r)F)rN)__name__ __module__ __qualname____firstlineno____doc__booltupleintrrrrr!r%r)r,r/r r4strr8rEobjectrI__static_attributes__ __classcell__)rs@rrr s'V! 0(,  0 0CHo$ 0 $ : 0  0 0! 5(,  5 5CHo$ 5 $ : 5  5 5  eCHo(+(s(t(, &Trr) rAtypingrtyping_extensionsrr;torch._Crr__all__rrr\s- " &e eP )r