tj\ddlZddlmZddlmZddlZddlmZGddeZdgZ dS)N)Literal)Self)_acceleratorGraphc @eZdZdZ dddddedeeefdzded d effd Z dddddedeeefdzded d 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() FNdefaultpoolcapture_error_mode keep_graphr r )rglobal thread_localrelaxedreturncHt||SN)super__new__)clsr r r __class__s V/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/accelerator/graphs.pyrz Graph.__new__3swwsJ///cft|||_||_dSr)r__init__ graph_poolr )selfr r r rs rrzGraph.__init__>s2 $$$"4rcbt|j|jdS)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: T5L      rcHtdS)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! rcHtdS)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"rcHtdS)z'Replay the work captured by this graph.N)rreplayrs rr&z Graph.replaygs rcHtdS)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  rcDtS)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$ww||~~rcDtS)z)Enable debugging mode for ``debug_dump``.)renable_debug_moders rr+zGraph.enable_debug_modesww((***rpathcFt|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(ww!!$'''rc4tjtjjjrt jtjtj | dSr) torch accelerator synchronizecompilerconfigforce_cudagraph_gcgccollect empty_cacheempty_host_cacher)rs r __enter__zGraph.__enter__sv %%''' > 3  JLLL %%''' **,,, rexc_infoc.|dSr)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 0 0 0CHo$ 0 $ : 0  0 0 0 0 0 0! 5(,  5 5 5 5CHo$ 5 $ : 5  5 5 5 5 5 5       eCHo(++++++(s(t((((((,    &Trr) r6typingrtyping_extensionsrr0torch._Crr__all__rrrMs """""" &&&&&&eeeee eeeP )r