+ jV^RIt^RIHt^RIHt^RIt^RIHt!RR]4tR.t R#)N)Literal)Self)_acceleratorGraphc^aa]tRt^ toRtRRRRR/V3RlV3RlllltRRRRR/V3RlV3R lllltV3R lV3R lltV3R lV3R lltV3RlV3Rllt V3RlV3Rllt V3RlV3Rllt V3RlV3Rllt V3RlV3Rllt V3RlV3RlltV3RlRltV3RlRltRtVtV;t#) 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() poolNcapture_error_modedefaultcd<V^8dQhRS[RS[S[S[3,R,RS[R,RS[/# keep_graphrNr return)r global thread_localrelaxed)booltupleintrr)format __classdict__s"Y/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/accelerator/graphs.py __annotate__Graph.__annotate__3sH 0 0 0CHo$ 0 $ : 0  0c"<\SV`W4#N)super__new__)clsrrr __class__s&&$$rr Graph.__new__3sws//rcb<V^8dQhRS[RS[S[S[3,R,RS[R,RR/#r )rrrr)rrs"rrr>sH 5 5 5CHo$ 5 $ : 5  5rc><\SV`V4W nW0nR#r)r__init__ graph_poolr )selfrrr r!s&&$$rr%Graph.__init__>s $"4rc<V^8dQhRR/#r rN)rrs"rrrLs   t  rc R<\SV`VPVPR7R#)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. )rr N)r capture_beginr&r r'r!s&rr-Graph.capture_beginLs& T5L5L  rc<V^8dQhRR/#r*r+)rrs"rrrWTrc $<\SV`4R#)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&rr3Graph.capture_endW rc<V^8dQhRR/#r*r+)rrs"rrr_r1rc $<\SV`4R#)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&rr8Graph.instantiate_r5rc<V^8dQhRR/#r*r+)rrs"rrrgsrc $<\SV`4R#)z'Replay the work captured by this graph.N)rreplayr.s&rr< Graph.replaygs  rc<V^8dQhRR/#r*r+)rrs"rrrkstrc $<\SV`4R#)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  rc6<V^8dQhRS[S[S[3,/#)r r)rr)rrs"rrrtseCHorc <\SV`4#)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) )rrr.s&rr Graph.poolts$w|~rc<V^8dQhRR/#r*r+)rrs"rrrs++4+rc <\SV`4#)z)Enable debugging mode for ``debug_dump``.)renable_debug_moder.s&rrGGraph.enable_debug_modesw(**rc$<V^8dQhRS[RR/#)r pathrN)str)rrs"rrrs((s(t(rc "<\SV`V4#)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)r'rJr!s&&rrMGraph.debug_dumps(w!$''rc<V^8dQhRR/#r*r+)rrs"rrrs  4 rcX\PP4\PPP 'd\ P!4\PP4\PP4VP4R#r) torch accelerator synchronizecompilerconfigforce_cudagraph_gcgccollect empty_cacheempty_host_cacher-)r's&r __enter__Graph.__enter__se %%' >> 3 3 3 JJL %%' **, rc$<V^8dQhRS[RR/#)r exc_inforN)object)rrs"rrrs&Trc&VP4R#r)r3)r'r^s&*r__exit__Graph.__exit__s r)r r&)F)__name__ __module__ __qualname____firstlineno____doc__rr%r-r3r8r<r@rrGrMr[ra__static_attributes____classdictcell__ __classcell__)r!rs@@rrr s'R 0(, 0  0 0 5(, 5  5 5   (++((,  rr) rWtypingrtyping_extensionsrrQtorch._Crr__all__r+rrros- " &e eP )r