3iWUddlmZddlZddlmZddlmZmZmZmZm Z ddl m Z m Z m Z ddlZddlmZerddlmZdd lmZgd Ze d Ze d Zeej0d s]edej0j2d<edej0j2d<edej0j2d<ddlmZmZmZddZd dZGddeZ GddZ!e dede"ffZ#de$d<e d! d"dZ%e d! d#dZ% d! d$dZ%y)%) annotationsN)Callable)Optionaloverload TYPE_CHECKING TypeAliasUnion) ParamSpecSelfTypeVar)Tensor) _POOL_HANDLE) _dummy_type)is_current_stream_capturinggraph_pool_handleXPUGraphgraphmake_graphed_callables_R_P_XpuStreamBase _XPUGraph_xpu_graph_pool_handle_xpu_isCurrentStreamCapturing)rrrctS)zReturn True if XPU graph capture is underway on the current XPU stream, False otherwise. If a XPU context does not exist on the current device, returns False without initializing the context. )rR/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/torch/xpu/graphs.pyrr)s ) **rcPtjjtS)zBReturn an opaque token representing the id of a graph memory pool.)torchxpurrrrrrr1s 99 ! !"8": ;;rceZdZdZd dfd Zddfd Zdfd Zdfd Zdfd Zdfd Z dfd Z dfd Z dfd Z dfd Z dfd ZxZS)raWrapper around a XPU graph. Arguments: keep_graph (bool, optional): If ``keep_graph=False``, the executable command graph will be instantiated on GPU at the end of ``capture_end`` and the underlying modifiable command graph will be destroyed. Note that the executable command graph will not be instantiated at the end of ``capture_end`` in this case. Instead, it will be instantiated via an explicit called to ``instantiate`` or automatically on the first call to ``replay`` if ``instantiate`` was not already called. Calling ``instantiate`` manually before ``replay`` is recommended to prevent increased latency on the first call to ``replay``. c$t|||SN)super__new__)cls keep_graph __class__s rr'zXPUGraph.__new__GswsJ//rc&t||y)aBegin capturing XPU work on the current xpu stream. Typically, you shouldn't call ``capture_begin`` yourself. Use :class:`~torch.xpu.graph`, which call ``capture_begin`` internally. Arguments: pool (optional): Token (returned by :func:`~torch.xpu.graph_pool_handle` or :meth:`other_Graph_instance.pool()`) that hints this graph may share memory with the indicated pool. poolN)r& capture_begin)selfr-r*s rr.zXPUGraph.capture_beginJs 4(rc"t|y)aEnd XPU graph capture on the current stream. After ``capture_end``, ``replay`` may be called on this instance. Typically, you shouldn't call ``capture_end`` yourself. Use :class:`~torch.xpu.graph`, which call ``capture_end`` internally. N)r& capture_endr/r*s rr1zXPUGraph.capture_endWs rc"t|y)a/Instantiate the XPU 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. Does not destroy the xpu modify command graph returned by ``raw_xpu_graph``. N)r& instantiater2s rr4zXPUGraph.instantiateas rc"t|y)z+Replay the XPU work captured by this graph.N)r&replayr2s rr6zXPUGraph.replayjs  rc"t|y)z1Delete the graph currently held by this instance.N)r&resetr2s rr8zXPUGraph.resetns   rc t|S)zReturn 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. )r&r-r2s rr-z XPUGraph.poolrs w|~rc t|S)z.Enable debugging mode for XPUGraph.debug_dump.)r&enable_debug_moder2s rr;zXPUGraph.enable_debug_modezsw(**rc"t||S)z Arguments: debug_path (required): Path to dump the graph to. Calls a debugging function to dump the graph if the debugging is enabled via XPUGraph.enable_debug_mode() )r& debug_dump)r/ debug_pathr*s rr=zXPUGraph.debug_dump~sw!*--rc t|S)zReturns the underlying xpuGraph_t. ``keep_graph`` must be True. XPU doesn't provide APIs to manipulate this object. )r& raw_xpu_graphr2s rr@zXPUGraph.raw_xpu_graphs w$&&rc t|S)aReturns the underlying xpuGraphExec_t. ``instantiate`` must have been called if ``keep_graph`` is True, or ``capture_end`` must have been called if ``keep_graph`` is False. If you call ``instantiate()`` after ``raw_xpu_graph_exec()``, the previously returned xpuGraphExec_t will be destroyed. It is your responsibility not to use this object after destruction. XPU doesn't provide APIs to manipulate this object. )r&raw_xpu_graph_execr2s rrBzXPUGraph.raw_xpu_graph_execs w)++r)F)r)boolreturnr r%)r-Optional[_POOL_HANDLE]rDNonerDrFrDr)r>strrDrF)rDint)__name__ __module__ __qualname____doc__r'r.r1r4r6r8r-r;r=r@rB __classcell__)r*s@rrr6sD 0 )+.',,rrcHeZdZUdZdZded< d d dZd dZd dZy) raContext-manager that captures XPU work into a :class:`torch.xpu.XPUGraph` object for later replay. Arguments: xpu_graph (torch.xpu.XPUGraph): Graph object used for capture. pool (optional): Opaque token (returned by a call to :func:`~torch.xpu.graph_pool_handle()` or :meth:`other_Graph_instance.pool()`) hinting this graph's capture may share memory from the specified pool. stream (torch.xpu.Stream, optional): If supplied, will be set as the current stream in the context. If not supplied, ``graph`` sets its own internal side stream as the current stream in the context. .. note:: For effective memory sharing, if you pass a ``pool`` used by a previous capture and the previous capture used an explicit ``stream`` argument, you should pass the same ``stream`` argument to this capture. NOptional[torch.xpu.Stream]default_capture_streamc>|jj-tjj |j_|dn|f|_||n|jj|_|j td|j |_||_ y)Nrzcapture_stream must not be None) r*rRr!r"Streamr-capture_streamAssertionError stream_ctx xpu_graph)r/rXr-streams r__init__zgraph.__init__s >> 0 0 849II4D4D4FDNN 1,BTG (Fdnn.S.S     & !BC C--"rctjjtjj|jj |j j|jyr%) r!r" synchronize empty_cacherW __enter__rXr.r-)r/s rr^zgraph.__enter__sJ   !!#$$$dii0rcj|jj|jj|yr%)rXr1rW__exit__)r/argss rr`zgraph.__exit__s& ""$   $'r)NN)rXrr-rErYrQrG)raobjectrDrF) rKrLrMrNrR__annotations__rZr^r`rrrrrsH :>6= (,-1 ##%#+ #.1(rrtorch.nn.Module.r_ModuleOrCallablecyr%r callables sample_argsnum_warmup_itersallow_unused_inputr-s rrrsrcyr%rrgs rrrs%(rc |tjrtjr tdd}t |t s*d}|f}t jt tdf|f}n,t jt t tdfdf|}g}t||D]\}} t |tjjr~t|jdk(r0t|jdk(rt|jdk(s tdt!d|j#Ds tdtj$j&j(| } |j+t | t!d | Drt-d |D cgc] } t| } } |Dcgc]A}t |tjjrt |j/nd C} }t1t|D cgc] } || | | z}} t1t|Dcgc] }tj2j5"}}t1t|Dcgc] }tj2j5"}}| t7n|}tj2j9tj2j;tj2j=5t|||D]\}} }d \}}}t1|D]}tj$j&j?|| }t d|D}t|dkDsPtj@jC|t d|Dt d|Dd|}|||fD]}~ d d d tj2j9g}g}t|||D]\}} }tj2jE||5|| }d d d tj$j&jG\}}|j+t ||j+|g}g} ttI|tI|tI|D]\}}!}"t d|!D}#t d|!D}d }t|dkDrntj2jE|"|5tj@jC|t d|Dt d|#Dd|}d d d g}$d}%|D];}&|&jJr||$j+||%|%dz }%+|$j+d =t |$}$|j+|#| j+|$|jM| jM dd}'g}(tO|D]\} }|'|| || | | | | || || || || | |  })t |tjjrD dd}*|*||jP|)|jR|_)|(j+||(j+|)|r|(dSt |(Scc} wcc}wcc} wcc}wcc}w#1swY.xYw#1swYxYw#1swYxYw)a Accept callables (functions or :class:`nn.Module`\ s) and returns graphed versions. Each graphed callable's forward pass runs its source callable's forward XPU work as a XPU graph inside a single autograd node. The graphed callable's forward pass also appends a backward node to the autograd graph. During backward, this node runs the callable's backward work as a XPU graph. Therefore, each graphed callable should be a drop-in replacement for its source callable in an autograd-enabled training loop. See :ref:`Partial-network capture` for detailed use and constraints. If you pass a tuple of several callables, their captures will use the same memory pool. Arguments: callables (torch.nn.Module or Python function, or tuple of these): Callable or callables to graph. If you pass a tuple of callables, their order in the tuple must be the same order they'll run in the live workload. sample_args (tuple of Tensors, or tuple of tuples of Tensors): Samples args for each callable. If a single callable was passed, ``sample_args`` must be a single tuple of argument Tensors. If a tuple of callables was passed, ``sample_args`` must be tuple of tuples of argument Tensors. num_warmup_iters (int): The number of warmup iterations. Currently, ``DataDistributedParallel`` needs 11 iterations for warm up. Default: ``3``. allow_unused_input (bool): If False, specifying inputs that were not used when computing outputs (and therefore their grad is always zero) is an error. Defaults to False. pool (optional): Token (returned by :func:`~torch.xpu.graph_pool_handle` or :meth:`other_Graph_instance.pool()`) that hints this graph may share memory with the indicated pool. .. note:: The ``requires_grad`` state of each Tensor in ``sample_args`` must match the state that's expected for the corresponding real input in the training loop. .. warning:: This API is in beta and may change in future releases. .. warning:: ``sample_args`` for each callable must contain only Tensors. Other types are not allowed. .. warning:: Returned callables do not support higher order differentiation (e.g., double backward). .. warning:: In any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. Buffers must have ``requires_grad=False``. .. warning:: After you pass a :class:`torch.nn.Module` through :func:`~make_graphed_callables`, you may not add or remove any of that Module's parameters or buffers. .. warning:: :class:`torch.nn.Module`\s passed to :func:`~torch.xpu.make_graphed_callables` must not have module hooks registered on them at the time they are passed. However, registering hooks on modules *after* passing them through :func:`~torch.xpu.make_graphed_callables` is allowed. .. warning:: When running a graphed callable, you must pass its arguments in the same order and format they appeared in that callable's ``sample_args``. .. warning:: The automatic mixed precision is supported in :func:`~torch.xpu.make_graphed_callables` only with disabled caching. The context manager `torch.amp.autocast()` must have `cache_enabled=False`. z_make_graphed_callables does not support the autocast caching. Please set `cache_enabled=False`.FT.rzModules must not have hooks registered at the time they are passed. However, registering hooks on modules after passing them through make_graphed_callables is allowed.c38K|]}|jduyw)FN requires_grad.0bs r z)make_graphed_callables..IsEAq%/EszIn any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. All buffers must have ``requires_grad=False``.c3PK|]}t|tj ywr%) isinstancer!r )rrargs rrtz)make_graphed_callables..QsHS:c5<<0Hs$&zfIn the beta API, sample_args for each callable must contain only Tensors. Other types are not allowed.rN)NNNc3:K|]}|js|ywr%rorros rrtz)make_graphed_callables..qs$K11??Q$Kc3:K|]}|js|ywr%rorris rrtz)make_graphed_callables..us%"#qA%r{c3`K|]&}|jstj|(ywr%rpr! empty_likerys rrtz)make_graphed_callables..xs&+45AOOE,,Q/+s..)outputsinputs grad_outputs only_inputs allow_unusedr,c3bK|]'}|jrtj|nd)ywr%rrys rrtz)make_graphed_callables..s+$ AB1??E  Q  <$ s-/c3:K|]}|js|ywr%rorys rrtz)make_graphed_callables..sJ1!//QJr{c3:K|]}|js|ywr%ror}s rrtz)make_graphed_callables..s TqAOO Tr{c3&K|] }|| ywr%rrys rrtz)make_graphed_callables..s&WQq&Wsc  Gfddtjj d fd } | S)NceZdZedfd Zeej jjdfd Z y)Omake_graphed_callables..make_graphed_autograd_function..GraphedctD]A}|j||jk7s+|j||Cjt t s t dt dDS)Nzstatic_outputs must be a tuplec3<K|]}|jywr%detachrys rrtzjmake_graphed_callables..make_graphed_autograd_function..Graphed.forward..s@AQXXZ@s)rangedata_ptrcopy_r6rvtuple RuntimeError)ctxrr~ fwd_graph len_user_argsstatic_input_surfacestatic_outputss rforwardzWmake_graphed_callables..make_graphed_autograd_function..Graphed.forwards}-AA+A.779VAY=O=O=QQ,Q/55fQi@A  "!.%8&'GHH@@@@rct|tk7r#tdtdt|t|D];\}}| |j|jk7s+|j |=j t ts tdtdDS)Nz Expected z gradients but got z"static_grad_inputs must be a tuplec3DK|]}||jn|ywr%rrqs rrtzkmake_graphed_callables..make_graphed_autograd_function..Graphed.backward..s)#$-AHHJQ6s )lenrziprrr6rvr)rgradsggrad bwd_graphstatic_grad_inputsstatic_grad_outputss rbackwardzXmake_graphed_callables..make_graphed_autograd_function..Graphed.backwardsu:%8!99&#C(;$<#==PQTUZQ[P\] ##6>*GAt}::<4==?:GGDM*  "!"4e<&'KLL0rN)rrbrr rDtuple[Tensor, ...])rrbrr rDr) rKrLrM staticmethodrr!autogradfunctiononce_differentiabler)rrrrrrrsrGraphedrsC  A A ^^ $ $ 8 8 9 rrctjjj|}jt |z}tjjj |Sr%)r!utils_pytreearg_tree_leavesapplyrtree_unflatten) user_argsflatten_user_argsoutr module_paramsoutput_unflatten_specs rfunctionalizedzVmake_graphed_callables..make_graphed_autograd_function..functionalizedsW % 3 3 C CY O '--%(9":]"JLC;;&&55c;PQ Qr)rrbrDrb)r!rFunction) rrrrrrrrrrrs ````````` @rmake_graphed_autograd_functionz>make_graphed_callables..make_graphed_autograd_functions.! ! enn--! F R rc dfd }|S)NcBjk(r|i|S|i|Sr%)training)r user_kwargsfuncgraph_training_stategraphedorig_fwds rnew_fwdzEmake_graphed_callables..make_graphed_forward..new_fwds0}}(<<& A[AA'BkBBr)rz_P.argsrz _P.kwargsrDrr)rrrrrs```` rmake_graphed_forwardz4make_graphed_callables..make_graphed_forwards CC r)rrrrrztuple[torch.nn.Parameter, ...]rrJrztorch.utils._pytree.TreeSpecrrrrrztuple[Optional[Tensor], ...]rrrDzCallable[..., object]) rrdrrCrCallable[_P, _R]rrrDr)*r!is_autocast_enabledis_autocast_cache_enabledrrvrtypingcastr rnnModuler_backward_hooks_forward_hooks_forward_pre_hooksallbuffersrrrappend TypeError parametersrr"rrr\rYrT tree_leavesrrr tree_flattenreversedrpreverse enumeraterr)+rhrirjrkr-just_one_callable _sample_argsflatten_sample_argscra flatten_argper_callable_len_user_argsper_callable_module_paramsr~"per_callable_static_input_surfaces_ fwd_graphs bwd_graphsmempoolrr grad_inputsr outputs_gradvper_callable_static_outputs"per_callable_output_unflatten_specr func_outputsflatten_outputsspec per_callable_static_grad_outputsper_callable_static_grad_inputsrrrrgrad_idxrwrretrrs+ rrrssN   "u'F'F'H m   i ' L  E&#+$6 DF {{5vs{);S)@#A;O y,/4 a )A%%&!+(()Q.,,-2"aEEE"1 kk))994@ ""5#56HKHH^ )69L!L#d)!L!L" ",Auxx!?allnRG"" s9~&*  A!;A!>>*&* 16c)n0EF1%))$$&FJF05c)n0EF1%))$$&FJF%)\!tG II   %))**, -03 |%G1   ,D$,2B .K,+, ++--99$+F$$K$KK |$q("'.."5"5 ,$%';% &++9@+&%)%7#6 #K  |[9  ' . II#%)+&!$Y j!I8dI YY__YW_ 5 ';L '!& 3 3 @ @ N#**5+AB*11$78(*$&(#;>34,-< C7ni $$ FT$  JJJ  | q 9 #nn11( T,@ TT!&&W2E&W!W $!3 2   ' 0C  [%<"))+h*?@A "))$/  0 ##56(//0CD'../ABA CF%,,.#++-44464 4 < 4 1 4+4:4/4 4l$&CY'" 40 qM qM &q ) &q ) .q 1 .q 1 ' * ,Q / +A .   dEHHOO , % &* * +  " 0dmmWdllDL JJt  JJw E" H1v :{"M"* GF < ' ',  sL6[>A\,\%\ %\!A5\A\ \$:A\1\!$\. 1\; )rDrCrH)FN) rhrerirrjrJrkrCr-rErDre) rhtuple[_ModuleOrCallable, ...]riztuple[tuple[Tensor, ...], ...]rjrJrkrCr-rErDr) rh7Union[_ModuleOrCallable, tuple[_ModuleOrCallable, ...]]riz9Union[tuple[Tensor, ...], tuple[tuple[Tensor, ...], ...]]rjrJrkrCr-rErDr)& __future__rrcollections.abcrrrrrr typing_extensionsr r r r!r torch.xpur_utilsr__all__rrhasattr_C__dict__torch._Crrrrrrrrbrercrrrrrs" $FF66 &   T]t_uxx)*%0%=EHHk"2=>V2WEHH./9D':EHH56 VU+< ^,y^,B5(5(p %%6f8M%MN9N $#'  #  !     $#' (,(/(( ( ! ( # ( ($#' pFpJpp p ! p = pr