o j9:j@sNddlZddlmZddlmZddlZddlmZGdddeZdgZ dS)N)Literal)Self)_acceleratorGraphc s(eZdZdZ d%ddddedeeefdBded d effd d Z d%ddddedeeefdBded d dffd dZ d&fdd Z d&fdd Z d&fdd Z d&fdd Zd&fdd Zd eeefffdd Zd&fdd Zded dffdd Zd&d d!Zd"ed dfd#d$ZZS)'Grapha\ 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() FNdefaultpoolcapture_error_mode keep_graphrr )rglobal thread_localrelaxedreturncst||SN)super__new__)clsr rr  __class___/home/nk/hobo-godmode/plappi-mvp/.venv/lib/python3.10/site-packages/torch/accelerator/graphs.pyr3s z Graph.__new__cst|||_||_dSr)r__init__ graph_poolr )selfr rr rrrr>s  zGraph.__init__cstj|j|jddS)a 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. rN)r capture_beginrr rrrrrLs zGraph.capture_beginctdS)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_endrrrrrWzGraph.capture_endcr)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 instantiaterrrrr_rzGraph.instantiatecr)z'Replay the work captured by this graph.N)rreplayrrrrr gsz Graph.replaycr)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)rresetrrrrr!ksz Graph.resetc tS)aT 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) )rrrrrrrts z Graph.poolcr")z)Enable debugging mode for ``debug_dump``.)renable_debug_moderrrrr#s zGraph.enable_debug_modepathcs t|S)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)rr$rrrr%s zGraph.debug_dumpcCs<tjtjjjrttjtj | dSr) torch accelerator synchronizecompilerconfigforce_cudagraph_gcgccollect empty_cacheempty_host_cacherrrrr __enter__s     zGraph.__enter__exc_infocGs |dSr)r)rr1rrr__exit__s zGraph.__exit__)F)rN)__name__ __module__ __qualname____doc__booltupleintrrrrrrrr r!rr#strr%r0objectr2 __classcell__rrrrr sT+     r) r,typingrtyping_extensionsrr&torch._Crr__all__rrrrs    )