LjTddlZddlmZddlmZddlZddlmZGddeZdgZ y)N)Literal)Self)_acceleratorGraphc "eZdZdZ dddddedeeefdzdedd effd Z dddddedeeefdzdedd dffd Z dfd Z dfd Z dfd Z dfd Zdfd Zd eeefffd Zdfd Zded dffd ZddZded dfdZxZS)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() Ndefaultpoolcapture_error_mode keep_graphr r )rglobal thread_localrelaxedreturnc$t|||SN)super__new__)clsr r r __class__s W/var/www/html/ia-enhanced/venv/lib/python3.12/site-packages/torch/accelerator/graphs.pyrz Graph.__new__3swsJ//c@t||||_||_yr)r__init__ graph_poolr )selfr r r rs rrzGraph.__init__>s! $"4rcPt||j|jy)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. r N)r capture_beginrr rrs rrzGraph.capture_beginLs& T5L5L  rc"t|y)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_endrs rr!zGraph.capture_endW rc"t|y)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 instantiaters rr$zGraph.instantiate_r"rc"t|y)z'Replay the work captured by this graph.N)rreplayrs rr&z Graph.replaygs  rc"t|y)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)rresetrs rr(z Graph.resetks  rc t|S)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) )rr rs rr z Graph.poolts$w|~rc t|S)z)Enable debugging mode for ``debug_dump``.)renable_debug_moders rr+zGraph.enable_debug_modesw(**rpathc"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,rs rr.zGraph.debug_dumps(w!$''rcHtjjtjjj rt jtjjtjj|jyr) torch accelerator synchronizecompilerconfigforce_cudagraph_gcgccollect empty_cacheempty_host_cacher)rs r __enter__zGraph.__enter__sb %%' >> 3 3 JJL %%' **, rexc_infoc$|jyr)r!)rr;s r__exit__zGraph.__exit__s r)F)rN)__name__ __module__ __qualname____doc__booltupleintrrrrrr!r$r&r(r r+strr.r:objectr= __classcell__)rs@rrr s'V! 0(,  0 0CHo$ 0 $ : 0  0! 5(,  5 5CHo$ 5 $ : 5  5  eCHo(+(s(t(, &Trr) r6typingrtyping_extensionsrr0torch._Crr__all__rrrMs- " &e eP )r