Coverage for cuda / core / graph / _subclasses.pyx: 80.23%

263 statements  

« prev     ^ index     » next       coverage.py v7.14.0, created at 2026-05-22 01:37 +0000

1# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 

2# 

3# SPDX-License-Identifier: Apache-2.0 

4  

5"""GraphNode subclasses — EmptyNode through SwitchNode.""" 

6  

7from __future__ import annotations 

8  

9from libc.stddef cimport size_t 

10from libc.stdint cimport uintptr_t 

11  

12from cuda.bindings cimport cydriver 

13  

14from cuda.core._event cimport Event 

15from cuda.core._launch_config cimport LaunchConfig 

16from cuda.core._module cimport Kernel 

17from cuda.core.graph._graph_definition cimport GraphCondition, GraphDefinition 

18from cuda.core.graph._graph_node cimport GraphNode 

19from cuda.core._resource_handles cimport ( 

20 EventHandle, 

21 GraphHandle, 

22 KernelHandle, 

23 GraphNodeHandle, 

24 as_cu, 

25 as_intptr, 

26 create_event_handle_ref, 

27 create_graph_handle_ref, 

28 create_kernel_handle_ref, 

29 graph_node_get_graph, 

30) 

31from cuda.core._utils.cuda_utils cimport HANDLE_RETURN 

32  

33from cuda.core.graph._utils cimport _is_py_host_trampoline 

34  

35from cuda.core._utils.cuda_utils import driver, handle_return 

36from cuda.core.typing import GraphConditionalType 

37  

38__all__ = [ 

39 'AllocNode', 

40 'ChildGraphNode', 

41 'ConditionalNode', 

42 'EmptyNode', 

43 'EventRecordNode', 

44 'EventWaitNode', 

45 'FreeNode', 

46 'HostCallbackNode', 

47 'IfElseNode', 

48 'IfNode', 

49 'KernelNode', 

50 'MemcpyNode', 

51 'MemsetNode', 

52 'SwitchNode', 

53 'WhileNode', 

54] 

55  

56  

57cdef bint _has_cuGraphNodeGetParams = False 

58cdef bint _version_checked = False 

59  

60cdef bint _check_node_get_params(): 

61 global _has_cuGraphNodeGetParams, _version_checked 

62 if not _version_checked: 1a

63 from cuda.core._utils.version import binding_version, driver_version 1a

64 _has_cuGraphNodeGetParams = ( 

65 driver_version() >= (13, 2, 0) and binding_version() >= (13, 2, 0) 1a

66 ) 

67 _version_checked = True 1a

68 return _has_cuGraphNodeGetParams 1a

69  

70  

71cdef class EmptyNode(GraphNode): 

72 """An empty (synchronization) node.""" 

73  

74 @staticmethod 

75 cdef EmptyNode _create_impl(GraphNodeHandle h_node): 

76 cdef EmptyNode n = EmptyNode.__new__(EmptyNode) 2YdZdMib c d e 0d1d2d3d2 4du 3 5d6d7d8d9d4 !dZ 5 #dNi6 $d7 %d'd(d)dOi*d+dPi,d?e@e[e]e^eQiUhRiSiTiUi-d8 .d9 ! /d# :d$ ;d% =d' ?dN McNcJcBc@d[dAb( 0 ]d^d_d) v `d* {d+ n |d, f w x p - . / : h }d; ~d= ae? be@ [ ce] de^ ee_ fe` geO OcPcKcCcheieBb{ 1 jekele| y me} ne~ o oeabg z A q bbcbdbebi pefbqegbrehbFdB seibtejbuekbvelbwembxenbyeob

77 n._h_node = h_node 2YdZdMib c d e 0d1d2d3d2 4du 3 5d6d7d8d9d4 !dZ 5 #dNi6 $d7 %d'd(d)dOi*d+dPi,d?e@e[e]e^eQiUhRiSiTiUi-d8 .d9 ! /d# :d$ ;d% =d' ?dN McNcJcBc@d[dAb( 0 ]d^d_d) v `d* {d+ n |d, f w x p - . / : h }d; ~d= ae? be@ [ ce] de^ ee_ fe` geO OcPcKcCcheieBb{ 1 jekele| y me} ne~ o oeabg z A q bbcbdbebi pefbqegbrehbFdB seibtejbuekbvelbwembxenbyeob

78 return n 2YdZdMib c d e 0d1d2d3d2 4du 3 5d6d7d8d9d4 !dZ 5 #dNi6 $d7 %d'd(d)dOi*d+dPi,d?e@e[e]e^eQiUhRiSiTiUi-d8 .d9 ! /d# :d$ ;d% =d' ?dN McNcJcBc@d[dAb( 0 ]d^d_d) v `d* {d+ n |d, f w x p - . / : h }d; ~d= ae? be@ [ ce] de^ ee_ fe` geO OcPcKcCcheieBb{ 1 jekele| y me} ne~ o oeabg z A q bbcbdbebi pefbqegbrehbFdB seibtejbuekbvelbwembxenbyeob

79  

80 def __repr__(self) -> str: 

81 return f"<EmptyNode handle=0x{as_intptr(self._h_node):x}>" 2UhFd

82  

83  

84cdef class KernelNode(GraphNode): 

85 """A kernel launch node. 

86  

87 Properties 

88 ---------- 

89 grid : tuple of int 

90 Grid dimensions (gridDimX, gridDimY, gridDimZ). 

91 block : tuple of int 

92 Block dimensions (blockDimX, blockDimY, blockDimZ). 

93 shmem_size : int 

94 Dynamic shared memory size in bytes. 

95 kernel : Kernel 

96 The kernel object for this launch node. 

97 config : LaunchConfig 

98 A LaunchConfig reconstructed from this node's parameters. 

99 """ 

100  

101 @staticmethod 

102 cdef KernelNode _create_with_params(GraphNodeHandle h_node, 

103 tuple grid, tuple block, unsigned int shmem_size, 

104 KernelHandle h_kernel): 

105 """Create from known params (called by launch() builder).""" 

106 cdef KernelNode n = KernelNode.__new__(KernelNode) 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

107 n._h_node = h_node 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

108 n._grid = grid 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

109 n._block = block 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

110 n._shmem_size = shmem_size 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

111 n._h_kernel = h_kernel 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

112 return n 2zeegfggghgigjgkgQcAeRcBeScCeTcDeUcEeVcFeWclgXcLcYcZcsbmgngefGdogpgr ?e@e[e]e^el qgGergHesgtb0cIetg1c2cDcJeKeLeMeNeugOevgPewgN AbQexgC ReygSezgTeUeVepb9cAgBgn s CgDgWeEgf j XeFgYeGgZeHg0eIgub3c1eJg4c5cEc2e3e4e5e6eKg7eLg8eMgO Bb9eNgD !eOg#ePg$e%e'eqb!cQgRgo t SgTg(eUgg k )eVg*eWg+eXg#caf,eYg-eZg.e0g/e1g:e2g;e3g=e4g

113  

114 @staticmethod 

115 cdef KernelNode _create_from_driver(GraphNodeHandle h_node): 

116 """Create by fetching params from the driver (called by _create factory).""" 

117 cdef cydriver.CUgraphNode node = as_cu(h_node) 2QcXcLcYcZcsbr l

118 cdef cydriver.CUDA_KERNEL_NODE_PARAMS params 

119 with nogil: 2QcXcLcYcZcsbr l

120 HANDLE_RETURN(cydriver.cuGraphKernelNodeGetParams(node, &params)) 2QcXcLcYcZcsbr l

121 cdef KernelHandle h_kernel = create_kernel_handle_ref(params.kern) 2QcXcLcYcZcsbr l

122 return KernelNode._create_with_params( 2QcXcLcYcZcsbr l

123 h_node, 

124 (params.gridDimX, params.gridDimY, params.gridDimZ), 2QcXcLcYcZcsbr l

125 (params.blockDimX, params.blockDimY, params.blockDimZ), 2QcXcLcYcZcsbr l

126 params.sharedMemBytes, 

127 h_kernel) 

128  

129 def __repr__(self) -> str: 

130 return (f"<KernelNode handle=0x{as_intptr(self._h_node):x}" 2af

131 f" kernel=0x{as_intptr(self._h_kernel):x}>") 2af

132  

133 @property 

134 def grid(self) -> tuple: 

135 """Grid dimensions as a 3-tuple (gridDimX, gridDimY, gridDimZ).""" 

136 return self._grid 27gE

137  

138 @property 

139 def block(self) -> tuple: 

140 """Block dimensions as a 3-tuple (blockDimX, blockDimY, blockDimZ).""" 

141 return self._block 27gE

142  

143 @property 

144 def shmem_size(self) -> int: 

145 """Dynamic shared memory size in bytes.""" 

146 return self._shmem_size 27gE

147  

148 @property 

149 def kernel(self) -> Kernel: 

150 """The Kernel object for this launch node.""" 

151 return Kernel._from_handle(self._h_kernel) 27gE efGd

152  

153 @property 

154 def config(self) -> LaunchConfig: 

155 """A LaunchConfig reconstructed from this node's grid, block, and shmem_size. 

156  

157 Note: cluster dimensions and is_cooperative are not preserved 

158 by the CUDA driver's kernel node params, so they are not included. 

159 """ 

160 return LaunchConfig(grid=self._grid, block=self._block, 27gE

161 shmem_size=self._shmem_size) 27gE

162  

163  

164cdef class AllocNode(GraphNode): 

165 """A memory allocation node. 

166  

167 Properties 

168 ---------- 

169 dptr : int 

170 The device pointer for the allocation. 

171 bytesize : int 

172 The number of bytes allocated. 

173 device_id : int 

174 The device on which the allocation was made. 

175 memory_type : GraphMemoryType | str 

176 The type of memory allocated. 

177 peer_access : tuple of int 

178 Device IDs that have read-write access to this allocation. 

179 """ 

180  

181 @staticmethod 

182 cdef AllocNode _create_with_params(GraphNodeHandle h_node, 

183 cydriver.CUdeviceptr dptr, size_t bytesize, 

184 int device_id, str memory_type, tuple peer_access): 

185 """Create from known params (called by allocate() builder).""" 

186 cdef AllocNode n = AllocNode.__new__(AllocNode) 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

187 n._h_node = h_node 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

188 n._dptr = dptr 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

189 n._bytesize = bytesize 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

190 n._device_id = device_id 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

191 n._memory_type = memory_type 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

192 n._peer_access = peer_access 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

193 return n 2bfcf$cffgfhfifYdjfZdkflf%c'c(c)c*cb c d e P Q R S mfnfof0d1d2dpfqf3dHdId+cRc2 CbDbEbFbL rfM sf4dvbJdwbKdxb,cE Scu 3 F GbG HbH IbI Jbtf5duf6dvfwfxf7dyf8dzfAfBfCf9dLdMd-cTc4 KbLbMbNbObDfPbEfQb!dRbNdSbOdTb.cUbUcZ 5 VbWbXbYbZb0b1b2b3bFf4bGf5b#d6bPd7bQd8b/c9bVc6 !b#b$b%b'b(b)b*bHfIf$dRdSd:cWc7 +b,b-b.bJf%dKf'dLfMfNf(dOf)dPfQfRf*dSf+dTfUf,ddfVf;c=cWf-d?c8 /bXf.d@c9 :btbTdUd[c6cYfZf0c! ;b0f1f2f/d]c# =b3f:d^c$ ?b4f;d_c% @b5f=d`c' [b?dN McNcJcBc@d[dAb( 0 ]d^d6f_d{c) ]bC FcGcyb|c}cv T ~cad7f`dbd* ^b8f{dcd+ _bpbn s 9f|ddd, `bf w x p - . / : j U V J {b|bh }b~b!f}ded; ac#f~dfd= bc$faegd? cc%fbehd@ dcubVdWdid7c'f(f3c[ ec)f*f+fcejd] fc,fdekd^ gc-feeld_ hc.ffemd` icgeO OcPcKcCcheieBb{ 1 jeke/flend| jcD HcIczbodpdy W qdrd:fmesd} kc;fnetd~ lcqbo t =foeudabmcg z A q bbcbdbebk X Y K ncoci pcqc?fpevdfbrc@fqewdgbsc[frexdhbtc_eFd8cB rb]fseydibuc^ftezdjbvc_fueAdkbwc`fveBdlbxc{fweCdmbyc|fxeDdnbzc}fyeEdobAc

194  

195 @staticmethod 

196 cdef AllocNode _create_from_driver(GraphNodeHandle h_node): 

197 """Create by fetching params from the driver (called by _create factory).""" 

198 cdef cydriver.CUgraphNode node = as_cu(h_node) 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

199 cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS params 

200 with nogil: 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

201 HANDLE_RETURN(cydriver.cuGraphMemAllocNodeGetParams(node, &params)) 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

202  

203 cdef str memory_type 

204 if params.poolProps.allocType == cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_PINNED: 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

205 if params.poolProps.location.type == cydriver.CUmemLocationType.CU_MEM_LOCATION_TYPE_HOST: 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

206 memory_type = "host" 

207 else: 

208 memory_type = "device" 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

209 else: 

210 IF CUDA_CORE_BUILD_MAJOR >= 13: 

211 if params.poolProps.allocType == cydriver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_MANAGED: 

212 memory_type = "managed" 

213 else: 

214 memory_type = "device" 

215 ELSE: 

216 memory_type = "device" 

217  

218 cdef list peer_ids = [] 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

219 cdef size_t i 

220 for i in range(params.accessDescCount): 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

221 peer_ids.append(<int>params.accessDescs[i].location.id) 

222  

223 return AllocNode._create_with_params( 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

224 h_node, params.dptr, params.bytesize, 

225 <int>params.poolProps.location.id, memory_type, tuple(peer_ids)) 2L M vbwbxbE u F G H I ObPbQbRbSbTbUbZ VbXbZb1b3b4b5b6b7b8b9b!b$b'b)b

226  

227 def __repr__(self) -> str: 

228 return (f"<AllocNode handle=0x{as_intptr(self._h_node):x}" 2_e

229 f" dptr=0x{self._dptr:x} size={self._bytesize}>") 2_e

230  

231 @property 

232 def dptr(self) -> int: 

233 """The device pointer for the allocation.""" 

234 return self._dptr 2bfcf$c%c'c(c)c*cb c d e P Q R S NhOh+c2 CbDbEbFbL M ,c3 GbHbIbJb-c4 KbLbMbNb.c5 WbYb0b2b/c6 #b%b(b*b:c7 +b,b-b.bdf?c8 /b@c9 :b[c! ;b]c# =b^c$ ?b_c% @b`c' [bJc( 0 {c) ]bC FcGcyb|c}cv T ~cadbd* ^bcd+ _bpbn s dd, `bf w x p - . / : j U V J {b|bh }b~bed; acfd= bcgd? cchd@ dcid[ ecjd] fckd^ gcld_ hcmd` icKc{ 1 nd| jcD HcIczbodpdy W qdrdsd} kctd~ lcqbo t udabmcg z A q bbcbdbebk X Y K ncoci pcqcvdfbrcwdgbscxdhbtc8cB rbydibuczdjbvcAdkbwcBdlbxcCdmbycDdnbzcEdobAc

235  

236 @property 

237 def bytesize(self) -> int: 

238 """The number of bytes allocated.""" 

239 return self._bytesize 2NhOhL M

240  

241 @property 

242 def device_id(self) -> int: 

243 """The device on which the allocation was made.""" 

244 return self._device_id 2NhOhL M

245  

246 @property 

247 def memory_type(self) -> str: 

248 """The type of memory: ``"device"``, ``"host"``, or ``"managed"``.""" 

249 return self._memory_type 2NhOhL M

250  

251 @property 

252 def peer_access(self) -> tuple: 

253 """Device IDs with read-write access to this allocation.""" 

254 return self._peer_access 2NhOhL M

255  

256  

257cdef class FreeNode(GraphNode): 

258 """A memory deallocation node. 

259  

260 Properties 

261 ---------- 

262 dptr : int 

263 The device pointer being freed. 

264 """ 

265  

266 @staticmethod 

267 cdef FreeNode _create_with_params(GraphNodeHandle h_node, 

268 cydriver.CUdeviceptr dptr): 

269 """Create from known params (called by deallocate() builder).""" 

270 cdef FreeNode n = FreeNode.__new__(FreeNode) 2$c%c'c(c)c*cb c d e P Q R S +c,c-c.c/c:c?c@c[c]c^c_c`cJc{cC FcGcyb|c}cv T ~cadbdcdpbddedfdgdhdidjdkdldmdKcndD HcIczbodpdy W qdrdsdtdqbudvdwdxd8cydzdAdBdCdDdEd

271 n._h_node = h_node 2$c%c'c(c)c*cb c d e P Q R S +c,c-c.c/c:c?c@c[c]c^c_c`cJc{cC FcGcyb|c}cv T ~cadbdcdpbddedfdgdhdidjdkdldmdKcndD HcIczbodpdy W qdrdsdtdqbudvdwdxd8cydzdAdBdCdDdEd

272 n._dptr = dptr 2$c%c'c(c)c*cb c d e P Q R S +c,c-c.c/c:c?c@c[c]c^c_c`cJc{cC FcGcyb|c}cv T ~cadbdcdpbddedfdgdhdidjdkdldmdKcndD HcIczbodpdy W qdrdsdtdqbudvdwdxd8cydzdAdBdCdDdEd

273 return n 2$c%c'c(c)c*cb c d e P Q R S +c,c-c.c/c:c?c@c[c]c^c_c`cJc{cC FcGcyb|c}cv T ~cadbdcdpbddedfdgdhdidjdkdldmdKcndD HcIczbodpdy W qdrdsdtdqbudvdwdxd8cydzdAdBdCdDdEd

274  

275 @staticmethod 

276 cdef FreeNode _create_from_driver(GraphNodeHandle h_node): 

277 """Create by fetching params from the driver (called by _create factory).""" 

278 cdef cydriver.CUgraphNode node = as_cu(h_node) 

279 cdef cydriver.CUdeviceptr dptr 

280 with nogil: 

281 HANDLE_RETURN(cydriver.cuGraphMemFreeNodeGetParams(node, &dptr)) 

282 return FreeNode._create_with_params(h_node, dptr) 

283  

284 def __repr__(self) -> str: 

285 return f"<FreeNode handle=0x{as_intptr(self._h_node):x} dptr=0x{self._dptr:x}>" 28c

286  

287 @property 

288 def dptr(self) -> int: 

289 """The device pointer being freed.""" 

290 return self._dptr 21ixb

291  

292  

293cdef class MemsetNode(GraphNode): 

294 """A memset node. 

295  

296 Properties 

297 ---------- 

298 dptr : int 

299 The destination device pointer. 

300 value : int 

301 The fill value. 

302 element_size : int 

303 Element size in bytes (1, 2, or 4). 

304 width : int 

305 Width of the row in elements. 

306 height : int 

307 Number of rows. 

308 pitch : int 

309 Pitch in bytes (unused if height is 1). 

310 """ 

311  

312 @staticmethod 

313 cdef MemsetNode _create_with_params(GraphNodeHandle h_node, 

314 cydriver.CUdeviceptr dptr, unsigned int value, 

315 unsigned int element_size, size_t width, 

316 size_t height, size_t pitch): 

317 """Create from known params (called by memset() builder).""" 

318 cdef MemsetNode n = MemsetNode.__new__(MemsetNode) 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

319 n._h_node = h_node 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

320 n._dptr = dptr 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

321 n._value = value 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

322 n._element_size = element_size 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

323 n._width = width 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

324 n._height = height 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

325 n._pitch = pitch 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

326 return n 2b c d e P Q R S CbDbEbFbGbHbIbJbKbLbMbNbWbYb0b2b#b%b(b*b+b,b-b.bl Xd/b:b;b=b?b@b[b0 ]bT ^b_bs `bj U V J {b|bh }b~bacbcccdcecfcgchcic1 jcW kclct mck X Y K ncoci pcqcrcsctcrbucvcwcxcyczcAc

327  

328 @staticmethod 

329 cdef MemsetNode _create_from_driver(GraphNodeHandle h_node): 

330 """Create by fetching params from the driver (called by _create factory).""" 

331 cdef cydriver.CUgraphNode node = as_cu(h_node) 1l

332 cdef cydriver.CUDA_MEMSET_NODE_PARAMS params 

333 with nogil: 1l

334 HANDLE_RETURN(cydriver.cuGraphMemsetNodeGetParams(node, &params)) 1l

335 return MemsetNode._create_with_params( 1l

336 h_node, params.dst, params.value, 

337 params.elementSize, params.width, params.height, params.pitch) 1l

338  

339 def __repr__(self) -> str: 

340 return (f"<MemsetNode handle=0x{as_intptr(self._h_node):x}" 2rb

341 f" dptr=0x{self._dptr:x} value={self._value}>") 2rb

342  

343 @property 

344 def dptr(self) -> int: 

345 """The destination device pointer.""" 

346 return self._dptr 28g9g!g#gF G H I Xd

347  

348 @property 

349 def value(self) -> int: 

350 """The fill value.""" 

351 return self._value 28g9g!g#gF G H I Xd

352  

353 @property 

354 def element_size(self) -> int: 

355 """Element size in bytes (1, 2, or 4).""" 

356 return self._element_size 28g9g!g#gF G H I

357  

358 @property 

359 def width(self) -> int: 

360 """Width of the row in elements.""" 

361 return self._width 28g9g!g#gF G H I Xd

362  

363 @property 

364 def height(self) -> int: 

365 """Number of rows.""" 

366 return self._height 28g9g!g#gF G H I

367  

368 @property 

369 def pitch(self) -> int: 

370 """Pitch in bytes (unused if height is 1).""" 

371 return self._pitch 28g9g!g#gF G H I

372  

373  

374cdef class MemcpyNode(GraphNode): 

375 """A memcpy node. 

376  

377 Properties 

378 ---------- 

379 dst : int 

380 The destination pointer. 

381 src : int 

382 The source pointer. 

383 size : int 

384 The number of bytes copied. 

385 """ 

386  

387 @staticmethod 

388 cdef MemcpyNode _create_with_params(GraphNodeHandle h_node, 

389 cydriver.CUdeviceptr dst, cydriver.CUdeviceptr src, 

390 size_t size, cydriver.CUmemorytype dst_type, 

391 cydriver.CUmemorytype src_type): 

392 """Create from known params (called by memcpy() builder).""" 

393 cdef MemcpyNode n = MemcpyNode.__new__(MemcpyNode) 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

394 n._h_node = h_node 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

395 n._dst = dst 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

396 n._src = src 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

397 n._size = size 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

398 n._dst_type = dst_type 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

399 n._src_type = src_type 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

400 return n 2b c d e 2 3 4 5 6 7 8 9 ! # $ % ' ( ) v * + n , f w x p - . / : h ; = ? @ [ ] ^ _ ` { | y } ~ o abg z A q bbcbdbebi fbgbhbB ibjbkblbmbnbob

401  

402 @staticmethod 

403 cdef MemcpyNode _create_from_driver(GraphNodeHandle h_node): 

404 """Create by fetching params from the driver (called by _create factory).""" 

405 cdef cydriver.CUgraphNode node = as_cu(h_node) 

406 cdef cydriver.CUDA_MEMCPY3D params 

407 with nogil: 

408 HANDLE_RETURN(cydriver.cuGraphMemcpyNodeGetParams(node, &params)) 

409  

410 cdef cydriver.CUdeviceptr dst 

411 cdef cydriver.CUdeviceptr src 

412 if params.dstMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

413 dst = <cydriver.CUdeviceptr><uintptr_t>params.dstHost 

414 else: 

415 dst = params.dstDevice 

416 if params.srcMemoryType == cydriver.CU_MEMORYTYPE_HOST: 

417 src = <cydriver.CUdeviceptr><uintptr_t>params.srcHost 

418 else: 

419 src = params.srcDevice 

420  

421 return MemcpyNode._create_with_params( 

422 h_node, dst, src, params.WidthInBytes, 

423 params.dstMemoryType, params.srcMemoryType) 

424  

425 def __repr__(self) -> str: 

426 cdef str dt = "H" if self._dst_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1B

427 cdef str st = "H" if self._src_type == cydriver.CU_MEMORYTYPE_HOST else "D" 1B

428 return (f"<MemcpyNode handle=0x{as_intptr(self._h_node):x}" 1B

429 f" dst=0x{self._dst:x}({dt}) src=0x{self._src:x}({st}) size={self._size}>") 1B

430  

431 @property 

432 def dst(self) -> int: 

433 """The destination pointer.""" 

434 return self._dst 2Viu

435  

436 @property 

437 def src(self) -> int: 

438 """The source pointer.""" 

439 return self._src 2Viu

440  

441 @property 

442 def size(self) -> int: 

443 """The number of bytes copied.""" 

444 return self._size 2Viu

445  

446  

447cdef class ChildGraphNode(GraphNode): 

448 """A child graph node. 

449  

450 Properties 

451 ---------- 

452 child_graph : GraphDefinition 

453 The embedded graph definition (non-owning wrapper). 

454 """ 

455  

456 @staticmethod 

457 cdef ChildGraphNode _create_with_params(GraphNodeHandle h_node, 

458 GraphHandle h_child_graph): 

459 """Create from known params (called by embed() builder).""" 

460 cdef ChildGraphNode n = ChildGraphNode.__new__(ChildGraphNode) 2zeAeBeCeDeEeFesbr GeHetbIe1c2cDcJeKeLeMeNeOePeN QeC ReSeTeWef j XeYeZe0eub1e4c5cEc2e3e4e5e6e7e8eO 9eD !e#e$e(eg k )e*e+e#c,e-e.e/e:e;e=e

461 n._h_node = h_node 2zeAeBeCeDeEeFesbr GeHetbIe1c2cDcJeKeLeMeNeOePeN QeC ReSeTeWef j XeYeZe0eub1e4c5cEc2e3e4e5e6e7e8eO 9eD !e#e$e(eg k )e*e+e#c,e-e.e/e:e;e=e

462 n._h_child_graph = h_child_graph 2zeAeBeCeDeEeFesbr GeHetbIe1c2cDcJeKeLeMeNeOePeN QeC ReSeTeWef j XeYeZe0eub1e4c5cEc2e3e4e5e6e7e8eO 9eD !e#e$e(eg k )e*e+e#c,e-e.e/e:e;e=e

463 return n 2zeAeBeCeDeEeFesbr GeHetbIe1c2cDcJeKeLeMeNeOePeN QeC ReSeTeWef j XeYeZe0eub1e4c5cEc2e3e4e5e6e7e8eO 9eD !e#e$e(eg k )e*e+e#c,e-e.e/e:e;e=e

464  

465 @staticmethod 

466 cdef ChildGraphNode _create_from_driver(GraphNodeHandle h_node): 

467 """Create by fetching params from the driver (called by _create factory).""" 

468 cdef cydriver.CUgraphNode node = as_cu(h_node) 1r

469 cdef cydriver.CUgraph child_graph = NULL 1r

470 with nogil: 1r

471 HANDLE_RETURN(cydriver.cuGraphChildGraphNodeGetGraph(node, &child_graph)) 1r

472 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 1r

473 cdef GraphHandle h_child = create_graph_handle_ref(child_graph, h_graph) 1r

474 return ChildGraphNode._create_with_params(h_node, h_child) 1r

475  

476 def __repr__(self) -> str: 

477 return (f"<ChildGraphNode handle=0x{as_intptr(self._h_node):x}" 2#c

478 f" child=0x{as_intptr(self._h_child_graph):x}>") 2#c

479  

480 @property 

481 def child_graph(self) -> "GraphDefinition": 

482 """The embedded graph definition (non-owning wrapper).""" 

483 return GraphDefinition._from_handle(self._h_child_graph) 2Qc2isbr

484  

485  

486cdef class EventRecordNode(GraphNode): 

487 """An event record node. 

488  

489 Properties 

490 ---------- 

491 event : Event 

492 The event being recorded. 

493 """ 

494  

495 @staticmethod 

496 cdef EventRecordNode _create_with_params(GraphNodeHandle h_node, 

497 EventHandle h_event): 

498 """Create from known params (called by record() builder).""" 

499 cdef EventRecordNode n = EventRecordNode.__new__(EventRecordNode) 2~fHdJdLdNdPdRdPh;cQhagbgGdVhWhTdXh1cYhZh0hMc1hcg`e2h3h4h5hFc6h7hUe8hw U 9h!h#h$hVd%h4c'h(h)hOc*hdg{e+h,h-h.hHc/h:h%e;hz X =h?h@h$g[h]h^h_h`h{h|h

500 n._h_node = h_node 2~fHdJdLdNdPdRdPh;cQhagbgGdVhWhTdXh1cYhZh0hMc1hcg`e2h3h4h5hFc6h7hUe8hw U 9h!h#h$hVd%h4c'h(h)hOc*hdg{e+h,h-h.hHc/h:h%e;hz X =h?h@h$g[h]h^h_h`h{h|h

501 n._h_event = h_event 2~fHdJdLdNdPdRdPh;cQhagbgGdVhWhTdXh1cYhZh0hMc1hcg`e2h3h4h5hFc6h7hUe8hw U 9h!h#h$hVd%h4c'h(h)hOc*hdg{e+h,h-h.hHc/h:h%e;hz X =h?h@h$g[h]h^h_h`h{h|h

502 return n 2~fHdJdLdNdPdRdPh;cQhagbgGdVhWhTdXh1cYhZh0hMc1hcg`e2h3h4h5hFc6h7hUe8hw U 9h!h#h$hVd%h4c'h(h)hOc*hdg{e+h,h-h.hHc/h:h%e;hz X =h?h@h$g[h]h^h_h`h{h|h

503  

504 @staticmethod 

505 cdef EventRecordNode _create_from_driver(GraphNodeHandle h_node): 

506 """Create by fetching params from the driver (called by _create factory).""" 

507 cdef cydriver.CUgraphNode node = as_cu(h_node) 

508 cdef cydriver.CUevent event 

509 with nogil: 

510 HANDLE_RETURN(cydriver.cuGraphEventRecordNodeGetEvent(node, &event)) 

511 cdef EventHandle h_event = create_event_handle_ref(event) 

512 return EventRecordNode._create_with_params(h_node, h_event) 

513  

514 def __repr__(self) -> str: 

515 return (f"<EventRecordNode handle=0x{as_intptr(self._h_node):x}" 2$g

516 f" event=0x{as_intptr(self._h_event):x}>") 2$g

517  

518 @property 

519 def event(self) -> Event: 

520 """The event being recorded.""" 

521 return Event._from_handle(self._h_event) 23ivbPh;cQh

522  

523  

524cdef class EventWaitNode(GraphNode): 

525 """An event wait node. 

526  

527 Properties 

528 ---------- 

529 event : Event 

530 The event being waited on. 

531 """ 

532  

533 @staticmethod 

534 cdef EventWaitNode _create_with_params(GraphNodeHandle h_node, 

535 EventHandle h_event): 

536 """Create from known params (called by wait() builder).""" 

537 cdef EventWaitNode n = EventWaitNode.__new__(EventWaitNode) 2~fIdKdMdOdQdSdagbg=cRh}h~hUdai2cbicidiNceicg|efigihiiiGcjikiVelix V minioipiWdqi5crisitiPcuidg}eviwixiyiIcziAi'eBiA Y CiDiEi%gFiGiHiIiJiKiLi

538 n._h_node = h_node 2~fIdKdMdOdQdSdagbg=cRh}h~hUdai2cbicidiNceicg|efigihiiiGcjikiVelix V minioipiWdqi5crisitiPcuidg}eviwixiyiIcziAi'eBiA Y CiDiEi%gFiGiHiIiJiKiLi

539 n._h_event = h_event 2~fIdKdMdOdQdSdagbg=cRh}h~hUdai2cbicidiNceicg|efigihiiiGcjikiVelix V minioipiWdqi5crisitiPcuidg}eviwixiyiIcziAi'eBiA Y CiDiEi%gFiGiHiIiJiKiLi

540 return n 2~fIdKdMdOdQdSdagbg=cRh}h~hUdai2cbicidiNceicg|efigihiiiGcjikiVelix V minioipiWdqi5crisitiPcuidg}eviwixiyiIcziAi'eBiA Y CiDiEi%gFiGiHiIiJiKiLi

541  

542 @staticmethod 

543 cdef EventWaitNode _create_from_driver(GraphNodeHandle h_node): 

544 """Create by fetching params from the driver (called by _create factory).""" 

545 cdef cydriver.CUgraphNode node = as_cu(h_node) 

546 cdef cydriver.CUevent event 

547 with nogil: 

548 HANDLE_RETURN(cydriver.cuGraphEventWaitNodeGetEvent(node, &event)) 

549 cdef EventHandle h_event = create_event_handle_ref(event) 

550 return EventWaitNode._create_with_params(h_node, h_event) 

551  

552 def __repr__(self) -> str: 

553 return (f"<EventWaitNode handle=0x{as_intptr(self._h_node):x}" 2%g

554 f" event=0x{as_intptr(self._h_event):x}>") 2%g

555  

556 @property 

557 def event(self) -> Event: 

558 """The event being waited on.""" 

559 return Event._from_handle(self._h_event) 24iwb=cRh

560  

561  

562cdef class HostCallbackNode(GraphNode): 

563 """A host callback node. 

564  

565 Properties 

566 ---------- 

567 callback : callable or None 

568 The Python callable (None for ctypes function pointer callbacks). 

569 """ 

570  

571 @staticmethod 

572 cdef HostCallbackNode _create_with_params(GraphNodeHandle h_node, 

573 object callable_obj, cydriver.CUhostFn fn, 

574 void* user_data): 

575 """Create from known params (called by callback() builder).""" 

576 cdef HostCallbackNode n = HostCallbackNode.__new__(HostCallbackNode) 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

577 n._h_node = h_node 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

578 n._callable = callable_obj 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

579 n._fn = fn 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

580 n._user_data = user_data 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

581 return n 2'g(g)g*g+g,g-g.g/g:g;g=g?g@g[g]g^g_g`g{g6c|gDc}g~gahBcbh`e|eybchdhehfhghhh9cihp J jhkhlhmh7cnhEcohphqhCcrh{e}ezbshthuhvhwhxh!cyhq K zhAhBh~eChDhEhFhGhHhIh

582  

583 @staticmethod 

584 cdef HostCallbackNode _create_from_driver(GraphNodeHandle h_node): 

585 """Create by fetching params from the driver (called by _create factory).""" 

586 cdef cydriver.CUgraphNode node = as_cu(h_node) 

587 cdef cydriver.CUDA_HOST_NODE_PARAMS params 

588 with nogil: 

589 HANDLE_RETURN(cydriver.cuGraphHostNodeGetParams(node, &params)) 

590  

591 cdef object callable_obj = None 

592 if _is_py_host_trampoline(params.fn): 

593 callable_obj = <object>params.userData 

594  

595 return HostCallbackNode._create_with_params( 

596 h_node, callable_obj, params.fn, params.userData) 

597  

598 def __repr__(self) -> str: 

599 if self._callable is not None: 2~e

600 name = getattr(self._callable, '__name__', '?') 2~e

601 return (f"<HostCallbackNode handle=0x{as_intptr(self._h_node):x}" 2~e

602 f" callback={name}>") 2~e

603 return (f"<HostCallbackNode handle=0x{as_intptr(self._h_node):x}" 

604 f" cfunc=0x{<uintptr_t>self._fn:x}>") 

605  

606 @property 

607 def callback(self): 

608 """The Python callable, or None for ctypes function pointer callbacks.""" 

609 return self._callable 25i6i

610  

611  

612cdef class ConditionalNode(GraphNode): 

613 """Base class for conditional nodes. 

614  

615 When created via builder methods (if_then, if_else, while_loop, switch), 

616 a specific subclass (IfNode, IfElseNode, WhileNode, SwitchNode) is 

617 returned. When reconstructed from the driver on CUDA 13.2+, the 

618 correct subclass is determined via cuGraphNodeGetParams. On older 

619 drivers, this base class is used as a fallback. 

620  

621 Properties 

622 ---------- 

623 condition : GraphCondition or None 

624 The condition variable controlling execution (None pre-13.2). 

625 cond_type : str or None 

626 The conditional type ("if", "while", or "switch"; None pre-13.2). 

627 branches : tuple of GraphDefinition 

628 The body graphs for each branch (empty pre-13.2). 

629 """ 

630  

631 @staticmethod 

632 cdef ConditionalNode _create_from_driver(GraphNodeHandle h_node): 

633 cdef ConditionalNode n 

634 if not _check_node_get_params(): 1a

635 n = ConditionalNode.__new__(ConditionalNode) 

636 n._h_node = h_node 

637 n._condition = None 

638 n._cond_type = cydriver.CU_GRAPH_COND_TYPE_IF 

639 n._branches = () 

640 return n 

641  

642 cdef cydriver.CUgraphNode node = as_cu(h_node) 1a

643 params = handle_return(driver.cuGraphNodeGetParams( 1a

644 <uintptr_t>node)) 1a

645 cond_params = params.conditional 1a

646 cdef int cond_type_int = int(cond_params.type) 1a

647 cdef unsigned int size = int(cond_params.size) 1a

648  

649 cdef GraphCondition condition = GraphCondition.__new__(GraphCondition) 1a

650 condition._c_handle = <cydriver.CUgraphConditionalHandle>( 1a

651 <unsigned long long>int(cond_params.handle)) 1a

652  

653 cdef GraphHandle h_graph = graph_node_get_graph(h_node) 1a

654 cdef list branch_list = [] 1a

655 cdef unsigned int i 

656 cdef GraphHandle h_branch 

657 if cond_params.phGraph_out is not None: 1a

658 for i in range(size): 1a

659 h_branch = create_graph_handle_ref( 1a

660 <cydriver.CUgraph><uintptr_t>int(cond_params.phGraph_out[i]), 1a

661 h_graph) 

662 branch_list.append(GraphDefinition._from_handle(h_branch)) 1a

663 cdef tuple branches = tuple(branch_list) 1a

664  

665 cdef type cls 

666 if cond_type_int == <int>cydriver.CU_GRAPH_COND_TYPE_IF: 1a

667 if size == 1: 

668 cls = IfNode 

669 else: 

670 cls = IfElseNode 

671 elif cond_type_int == <int>cydriver.CU_GRAPH_COND_TYPE_WHILE: 1a

672 cls = WhileNode 1a

673 else: 

674 cls = SwitchNode 

675  

676 n = cls.__new__(cls) 1a

677 n._h_node = h_node 1a

678 n._condition = condition 1a

679 n._cond_type = <cydriver.CUgraphConditionalNodeType>cond_type_int 1a

680 n._branches = branches 1a

681 return n 1a

682  

683 def __repr__(self) -> str: 

684 return f"<ConditionalNode handle=0x{as_intptr(self._h_node):x}>" 

685  

686 @property 

687 def condition(self) -> GraphCondition | None: 

688 """The condition variable controlling execution.""" 

689 return self._condition 25gJhShKh6gLhThMh

690  

691 @property 

692 def cond_type(self) -> GraphConditionalType | None: 

693 """The conditional type: GraphConditionalType.IF, .WHILE, or .SWITCH 

694  

695 Returns None when reconstructed from the driver pre-CUDA 13.2, 

696 as the conditional type cannot be determined. 

697 """ 

698 if self._condition is None: 25gJhShKh6gLhThMh

699 return None 

700 if self._cond_type == cydriver.CU_GRAPH_COND_TYPE_IF: 25gJhShKh6gLhThMh

701 return GraphConditionalType("if") 25gJh6gLh

702 elif self._cond_type == cydriver.CU_GRAPH_COND_TYPE_WHILE: 

703 return GraphConditionalType("while") 2KhMh

704 else: 

705 return GraphConditionalType("switch") 2ShTh

706  

707 @property 

708 def branches(self) -> tuple: 

709 """The body graphs for each branch as a tuple of GraphDefinition. 

710  

711 Returns an empty tuple when reconstructed from the driver 

712 pre-CUDA 13.2. 

713 """ 

714 return self._branches 25gJhShKh6gLhThMh7iYca

715  

716  

717cdef class IfNode(ConditionalNode): 

718 """An if-conditional node.""" 

719  

720 def __repr__(self) -> str: 

721 return (f"<IfNode handle=0x{as_intptr(self._h_node):x}" 2Wi

722 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Wi

723  

724 @property 

725 def then(self) -> "GraphDefinition": 

726 """The 'then' branch graph.""" 

727 return self._branches[0] 2JhLh8iXc

728  

729  

730cdef class IfElseNode(ConditionalNode): 

731 """An if-else conditional node.""" 

732  

733 def __repr__(self) -> str: 

734 return (f"<IfElseNode handle=0x{as_intptr(self._h_node):x}" 2Xi

735 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Xi

736  

737 @property 

738 def then(self) -> "GraphDefinition": 

739 """The ``then`` branch graph (executed when condition is non-zero).""" 

740 return self._branches[0] 25g6gYiLc

741  

742 @property 

743 def else_(self) -> "GraphDefinition": 

744 """The ``else`` branch graph (executed when condition is zero).""" 

745 return self._branches[1] 25g6gYiLc

746  

747  

748cdef class WhileNode(ConditionalNode): 

749 """A while-loop conditional node.""" 

750  

751 def __repr__(self) -> str: 

752 return (f"<WhileNode handle=0x{as_intptr(self._h_node):x}" 2Zi

753 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 2Zi

754  

755 @property 

756 def body(self) -> "GraphDefinition": 

757 """The loop body graph.""" 

758 return self._branches[0] 2KhMh9iZc

759  

760  

761cdef class SwitchNode(ConditionalNode): 

762 """A switch conditional node.""" 

763  

764 def __repr__(self) -> str: 

765 return (f"<SwitchNode handle=0x{as_intptr(self._h_node):x}" 20i

766 f" condition=0x{<unsigned long long>self._condition._c_handle:x}>") 20i